vc 自定义喜木按扭类

1. #if !defined(AFX_MYB_H__3832DDEF_0C12_11D5_B6BE_00E07D8144D0__INCLUDED_) 
2. #define AFX_MYB_H__3832DDEF_0C12_11D5_B6BE_00E07D8144D0__INCLUDED_ 
4. #if _MSC_VER > 1000 
5. #pragma once 
6. #endif 
7. // CXMButton.h : header file 
10. #define WM_CXSHADE_RADIO WM_USER+0x100 
11. / 
12. // CXMButton window 
13. class CXMButton : public CButton 
14. { 
15.     // Construction 
16. public: 
17.     CXMButton(); 
18.     
19.     // Attributes 
20. private: 
21.     
22.     // Operations 
23. public: 
24.     // Overrides 
25.     // ClassWizard generated virtual function overrides 
26.     //{{AFX_VIRTUAL(CxSkinButton) 
27. public: 
28.     virtual void DrawItem(LPDRAWITEMSTRUCT lpDrawItemStruct); 
29. protected: 
30.     virtual void PreSubclassWindow(); 
31.     //}}AFX_VIRTUAL 
32.     // Implementation 
33. public: 
34.     void SetToolTipText(CString s); 
35.     COLORREF SetTextColor(COLORREF new_color); 
36.     void SetSkin(UINT normal,UINT down, UINT over=0, UINT disabled=0, UINT focus=0,UINT mask=0, 
37.         short drawmode=1,short border=1,short margin=4); 
38.     virtual ~CXMButton(); 
39.     // Generated message map functions 
40. protected: 
41.     bool m_Checked; //radio &amt; check buttons 
42.     DWORD m_Style; //radio &amt; check buttons 
43.     bool m_tracking; 
44.     bool m_button_down; 
45.     void RelayEvent(UINT message, WPARAM wParam, LPARAM lParam); 
46.     CToolTipCtrl m_tooltip; 
47.     CBitmap m_bNormal,m_bDown,m_bDisabled,m_bMask,m_bOver,m_bFocus; //skin bitmaps 
48.     short m_FocusRectMargin; //dotted margin offset 
49.     COLORREF m_TextColor; //button text color 
50.     HRGN hClipRgn; //clipping region 
51.     BOOL m_Border; //0=flat; 1=3D; 
52.     short m_DrawMode; //0=normal; 1=stretch; 2=tiled; 
53.     HRGN CreateRgnFromBitmap(HBITMAP hBmp, COLORREF color); 
54.     void FillWithBitmap(CDC* dc, HBITMAP hbmp, RECT r); 
55.     void DrawBitmap(CDC* dc, HBITMAP hbmp, RECT r, int DrawMode); 
56.     int GetBitmapWidth (HBITMAP hBitmap); 
57.     int GetBitmapHeight (HBITMAP hBitmap); 
58.     //{{AFX_MSG(CxSkinButton) 
59.     afx_msg BOOL OnEraseBkgnd(CDC* pDC); 
60.     afx_msg void OnLButtonDown(UINT nFlags, CPoint point); 
61.     afx_msg void OnLButtonUp(UINT nFlags, CPoint point); 
62.     afx_msg void OnMouseMove(UINT nFlags, CPoint point); 
63.     afx_msg void OnLButtonDblClk(UINT nFlags, CPoint point); 
64.     afx_msg void OnKillFocus(CWnd* pNewWnd); 
65.     afx_msg BOOL OnClicked(); 
66.     afx_msg void OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags); 
67.     //}}AFX_MSG 
68.     afx_msg LRESULT OnMouseLeave(WPARAM, LPARAM); 
69.     afx_msg LRESULT OnRadioInfo(WPARAM, LPARAM); 
70.     afx_msg LRESULT OnBMSetCheck(WPARAM, LPARAM); 
71.     afx_msg LRESULT OnBMGetCheck(WPARAM, LPARAM); 
72.     DECLARE_MESSAGE_MAP() 
73. }; 
74. / 
75. //{{AFX_INSERT_LOCATION}} 
76. // Microsoft Visual C++ will insert additional declarations immediately before the previous line. 
77. #endif // !defined(AFX_MYB_H__3832DDEF_0C12_11D5_B6BE_00E07D8144D0__INCLUDED_)

 

1. // XMButton.cpp : implementation file
2. #include "stdafx.h" 
3. #include "XMButton.h"
5. #ifdef _DEBUG 
6. #define new DEBUG_NEW 
7. #undef THIS_FILE 
8. static char THIS_FILE[] = __FILE__; 
9. #endif 
11. / 
12. // CXMButton 
13. CXMButton::CXMButton() 
14. { 
15. m_DrawMode=1; // normal drawing mode 
16. m_FocusRectMargin=0; // disable focus dotted rect 
17. hClipRgn=NULL; // no clipping region 
18. m_TextColor=GetSysColor(COLOR_BTNTEXT); // default button text color 
19. m_button_down = m_tracking = m_Checked = false; 
20. } 
21. / 
22. CXMButton::~CXMButton() 
23. { 
24. if (hClipRgn) DeleteObject(hClipRgn); // free clip region 
25. } 
26. / 
27. BEGIN_MESSAGE_MAP(CXMButton, CButton) 
28. //{{AFX_MSG_MAP(CxSkinButton) 
29. ON_WM_ERASEBKGND() 
30. ON_WM_LBUTTONDOWN() 
31. ON_WM_LBUTTONUP() 
32. ON_WM_MOUSEMOVE() 
33. ON_WM_LBUTTONDBLCLK() 
34. ON_WM_KILLFOCUS() 
35. //ON_CONTROL_REFLECT_EX(BN_CLICKED, OnClicked) 
36. ON_WM_KEYDOWN() 
37. //}}AFX_MSG_MAP 
38. ON_MESSAGE(WM_MOUSELEAVE, OnMouseLeave) 
39. ON_MESSAGE(WM_CXSHADE_RADIO , OnRadioInfo) 
40. ON_MESSAGE(BM_SETCHECK , OnBMSetCheck) 
41. ON_MESSAGE(BM_GETCHECK , OnBMGetCheck) 
42. END_MESSAGE_MAP() 
43. / 
44. // CxSkinButton message handlers 
45. / 
46. void CXMButton::PreSubclassWindow() 
47. { 
48. m_Style=GetButtonStyle(); ///get specific BS_ styles 
49. if ((m_Style & BS_AUTOCHECKBOX)==BS_AUTOCHECKBOX) 
50. // ||((m_Style & BS_CHECKBOX)==BS_CHECKBOX)) 
51. m_Style=BS_CHECKBOX; 
52. else if ((m_Style & BS_AUTORADIOBUTTON)==BS_AUTORADIOBUTTON) 
53. // ||((m_Style & BS_RADIOBUTTON)==BS_RADIOBUTTON)) 
54. m_Style=BS_RADIOBUTTON; 
55. else { m_Style=BS_PUSHBUTTON; } 
57. CButton::PreSubclassWindow(); 
58. ModifyStyle(0, BS_OWNERDRAW); 
59. } 
60. / 
61. BOOL CXMButton::OnEraseBkgnd(CDC* pDC) 
62. { return 1; } // doesn't erase the button background 
63. / 
64. void CXMButton::DrawItem(LPDRAWITEMSTRUCT lpDrawItemStruct) 
65. { 
66. ASSERT (lpDrawItemStruct); 
67. //TRACE("* Captured: >08X/n", ::GetCapture()); 
69. //Check if the button state in not in inconsistent mode... 
70. POINT mouse_position; 
71. if ((m_button_down) && (::GetCapture() == m_hWnd) && (::GetCursorPos(&mouse_position))){ 
72. if (::WindowFromPoint(mouse_position) == m_hWnd){ 
73. if ((GetState() & BST_PUSHED) != BST_PUSHED) { 
74. //TRACE("* Inconsistency up detected! Fixing./n"); 
75. SetState(TRUE); 
76. return; 
77. } 
78. } else { 
79. if ((GetState() & BST_PUSHED) == BST_PUSHED) { 
80. //TRACE("* Inconsistency up detected! Fixing./n"); 
81. SetState(FALSE); 
82. return; 
83. } 
84. } 
85. } 
87. //TRACE("* Drawing: >08x/n", lpDrawItemStruct->itemState); 
88. CString sCaption; 
89. CDC *pDC = CDC::FromHandle(lpDrawItemStruct->hDC); // get device context 
90. RECT r=lpDrawItemStruct->rcItem; // context rectangle 
91. int cx = r.right - r.left ; // get width 
92. int cy = r.bottom - r.top ; // get height 
93. // get text box position 
94. RECT tr={r.left+m_FocusRectMargin+2,r.top,r.right-m_FocusRectMargin-2,r.bottom}; 
96. GetWindowText(sCaption); // get button text 
97. pDC->SetBkMode(TRANSPARENT); 
99. // Select the correct skin 
100. if (lpDrawItemStruct->itemState & ODS_DISABLED){ // DISABLED BUTTON 
101. if(m_bDisabled.m_hObject==NULL) 
102. // no skin selected for disabled state -> standard button 
103. pDC->FillSolidRect(&r,GetSysColor(COLOR_BTNFACE)); 
104. else // paint the skin 
105. DrawBitmap(pDC,(HBITMAP)m_bDisabled,r,m_DrawMode); 
106. // if needed, draw the standard 3D rectangular border 
107. if (m_Border) pDC->DrawEdge(&r,EDGE_RAISED,BF_RECT); 
108. // paint the etched button text 
109. pDC->SetTextColor(GetSysColor(COLOR_3DHILIGHT)); 
110. pDC->DrawText(sCaption,&tr,DT_SINGLELINE|DT_VCENTER|DT_CENTER); 
111. pDC->SetTextColor(GetSysColor(COLOR_GRAYTEXT)); 
112. OffsetRect(&tr,-1,-1); 
113. pDC->DrawText(sCaption,&tr,DT_SINGLELINE|DT_VCENTER|DT_CENTER); 
114. } else { // SELECTED (DOWN) BUTTON 
115. if ((lpDrawItemStruct->itemState & ODS_SELECTED)||m_Checked){ 
116. if(m_bDown.m_hObject==NULL) 
117. // no skin selected for selected state -> standard button 
118. pDC->FillSolidRect(&r,GetSysColor(COLOR_BTNFACE)); 
119. else { // paint the skin 
120. DrawBitmap(pDC,(HBITMAP)m_bDown,r,m_DrawMode); 
121. } 
122. OffsetRect(&tr,1,1); //shift text 
123. // if needed, draw the standard 3D rectangular border 
124. if (m_Border) pDC->DrawEdge(&r,EDGE_SUNKEN,BF_RECT); 
125. } else { // DEFAULT BUTTON 
126. if(m_bNormal.m_hObject==NULL) 
127. // no skin selected for normal state -> standard button 
128. pDC->FillSolidRect(&r,GetSysColor(COLOR_BTNFACE)); 
129. else // paint the skin 
130. if ((m_tracking)&&(m_bOver.m_hObject!=NULL)){ 
131. DrawBitmap(pDC,(HBITMAP)m_bOver,r,m_DrawMode); 
132. } else { 
133. if ((lpDrawItemStruct->itemState & ODS_FOCUS)&&(m_bFocus.m_hObject!=NULL)){ 
134. DrawBitmap(pDC,(HBITMAP)m_bFocus,r,m_DrawMode); 
135. } else { 
136. DrawBitmap(pDC,(HBITMAP)m_bNormal,r,m_DrawMode); 
137. } 
138. } 
139. // if needed, draw the standard 3D rectangular border 
140. if (m_Border) pDC->DrawEdge(&r,EDGE_RAISED,BF_RECT); 
141. } 
142. // paint the focus rect 
143. if ((lpDrawItemStruct->itemState & ODS_FOCUS)&&(m_FocusRectMargin>0)){ 
144. r.left += m_FocusRectMargin ; 
145. r.top += m_FocusRectMargin ; 
146. r.right -= m_FocusRectMargin ; 
147. r.bottom -= m_FocusRectMargin ; 
148. DrawFocusRect (lpDrawItemStruct->hDC, &r) ; 
149. } 
150. // paint the enabled button text 
151. pDC->SetTextColor(m_TextColor); 
152. pDC->DrawText(sCaption,&tr,DT_SINGLELINE|DT_VCENTER|DT_CENTER); 
153. } 
154. } 
155. / 
156. int CXMButton::GetBitmapWidth (HBITMAP hBitmap) 
157. { BITMAP bm; GetObject(hBitmap,sizeof(BITMAP),(PSTR)&bm); return bm.bmWidth;} 
158. / 
159. int CXMButton::GetBitmapHeight (HBITMAP hBitmap) 
160. { BITMAP bm; GetObject(hBitmap,sizeof(BITMAP),(PSTR)&bm); return bm.bmHeight;} 
161. / 
162. void CXMButton::DrawBitmap(CDC* dc, HBITMAP hbmp, RECT r, int DrawMode) 
163. { 
164. // DrawMode: 0=Normal; 1=stretch; 2=tiled fill 
165. if(DrawMode==2){ 
166. FillWithBitmap(dc,hbmp,r); 
167. return; 
168. } 
169. if(!hbmp) return; //safe check 
171. int cx=r.right - r.left; 
172. int cy=r.bottom - r.top; 
173. CDC dcBmp,dcMask; 
174. dcBmp.CreateCompatibleDC(dc); 
175. dcBmp.SelectObject(hbmp); 
177. if (m_bMask.m_hObject!=NULL){ 
178. dcMask.CreateCompatibleDC(dc); 
179. dcMask.SelectObject(m_bMask); 
181. CDC hdcMem; 
182. hdcMem.CreateCompatibleDC(dc); 
183. CBitmap hBitmap; 
184. hBitmap.CreateCompatibleBitmap(dc,cx,cy); 
185. hdcMem.SelectObject(hBitmap); 
187. hdcMem.BitBlt(r.left,r.top,cx,cy,dc,0,0,SRCCOPY); 
188. if(!DrawMode){ 
189. hdcMem.BitBlt(r.left,r.top,cx,cy,&dcBmp,0,0,SRCINVERT); 
190. hdcMem.BitBlt(r.left,r.top,cx,cy,&dcMask,0,0,SRCAND); 
191. hdcMem.BitBlt(r.left,r.top,cx,cy,&dcBmp,0,0,SRCINVERT); 
192. } else { 
193. int bx=GetBitmapWidth(hbmp); 
194. int by=GetBitmapHeight(hbmp); 
195. hdcMem.StretchBlt(r.left,r.top,cx,cy,&dcBmp,0,0,bx,by,SRCINVERT); 
196. hdcMem.StretchBlt(r.left,r.top,cx,cy,&dcMask,0,0,bx,by,SRCAND); 
197. hdcMem.StretchBlt(r.left,r.top,cx,cy,&dcBmp,0,0,bx,by,SRCINVERT); 
198. } 
199. dc->BitBlt(r.left,r.top,cx,cy,&hdcMem,0,0,SRCCOPY); 
201. hdcMem.DeleteDC(); 
202. hBitmap.DeleteObject(); 
204. DeleteDC(dcMask); 
205. } else { 
206. if(!DrawMode){ 
207. dc->BitBlt(r.left,r.top,cx,cy,&dcBmp,0,0,SRCCOPY); 
208. } else { 
209. int bx=GetBitmapWidth(hbmp); 
210. int by=GetBitmapHeight(hbmp); 
211. dc->StretchBlt(r.left,r.top,cx,cy,&dcBmp,0,0,bx,by,SRCCOPY); 
212. } 
213. } 
214. DeleteDC(dcBmp); 
215. } 
216. / 
217. void CXMButton::FillWithBitmap(CDC* dc, HBITMAP hbmp, RECT r) 
218. { 
219. if(!hbmp) return; 
220. CDC memdc; 
221. memdc.CreateCompatibleDC(dc); 
222. memdc.SelectObject(hbmp); 
223. int w = r.right - r.left; 
224. int h = r.bottom - r.top; 
225. int x,y,z; 
226. int bx=GetBitmapWidth(hbmp); 
227. int by=GetBitmapHeight(hbmp); 
228. for (y = r.top ; y < h ; y += by){ 
229. if ((y+by)>h) by=h-y; 
230. z=bx; 
231. for (x = r.left ; x < w ; x += z){ 
232. if ((x+z)>w) z=w-x; 
233. dc->BitBlt(x, y, z, by, &memdc, 0, 0, SRCCOPY); 
234. } 
235. } 
236. DeleteDC(memdc); 
237. } 
238. / 
239. void CXMButton::SetSkin(UINT normal,UINT down,UINT over,UINT disabled, UINT focus,UINT mask, 
240. short drawmode, short border, short margin) 
241. { 
242. m_bNormal.DeleteObject(); //free previous allocated bitmap 
243. m_bDown.DeleteObject(); 
244. m_bOver.DeleteObject(); 
245. m_bDisabled.DeleteObject(); 
246. m_bMask.DeleteObject(); 
247. m_bFocus.DeleteObject(); 
249. if (normal>0) m_bNormal.LoadBitmap(normal); 
250. if (down>0) m_bDown.LoadBitmap(down); 
251. if (over>0) m_bOver.LoadBitmap(over); 
252. if (focus>0) m_bFocus.LoadBitmap(focus); 
254. if (disabled>0) m_bDisabled.LoadBitmap(disabled); 
255. else if (normal>0) m_bDisabled.LoadBitmap(normal); 
257. m_DrawMode=max(0,min(drawmode,2)); 
258. m_Border=border; 
259. m_FocusRectMargin=max(0,margin); 
261. if (mask>0){ 
262. m_bMask.LoadBitmap(mask); 
263. if (hClipRgn) DeleteObject(hClipRgn); 
264. hClipRgn = CreateRgnFromBitmap(m_bMask,RGB(255,255,255)); 
265. if (hClipRgn){ 
266. SetWindowRgn(hClipRgn, TRUE); 
267. SelectClipRgn((HDC)GetDC(),hClipRgn); 
268. } 
269. if (m_DrawMode==0){ 
270. SetWindowPos(NULL,0,0,GetBitmapWidth(m_bMask), 
271. GetBitmapHeight(m_bMask),SWP_NOZORDER|SWP_NOMOVE); 
272. } 
273. } 
274. } 
275. / 
276. HRGN CXMButton::CreateRgnFromBitmap(HBITMAP hBmp, COLORREF color) 
277. { 
278. if (!hBmp) return NULL; 
280. BITMAP bm; 
281. GetObject( hBmp, sizeof(BITMAP), &bm ); // get bitmap attributes 
283. CDC dcBmp; 
284. dcBmp.CreateCompatibleDC(GetDC()); //Creates a memory device context for the bitmap 
285. dcBmp.SelectObject(hBmp); //selects the bitmap in the device context 
287. const DWORD RDHDR = sizeof(RGNDATAHEADER); 
288. const DWORD MAXBUF = 40; // size of one block in RECTs 
289. // (i.e. MAXBUF*sizeof(RECT) in bytes) 
290. LPRECT pRects; 
291. DWORD cBlocks = 0; // number of allocated blocks 
293. INT i, j; // current position in mask image 
294. INT first = 0; // left position of current scan line 
295. // where mask was found 
296. bool wasfirst = false; // set when if mask was found in current scan line 
297. bool ismask; // set when current color is mask color 
299. // allocate memory for region data 
300. RGNDATAHEADER* pRgnData = (RGNDATAHEADER*)new BYTE[ RDHDR + ++cBlocks * MAXBUF * sizeof(RECT) ]; 
301. memset( pRgnData, 0, RDHDR + cBlocks * MAXBUF * sizeof(RECT) ); 
302. // fill it by default 
303. pRgnData->dwSize = RDHDR; 
304. pRgnData->iType = RDH_RECTANGLES; 
305. pRgnData->nCount = 0; 
306. for ( i = 0; i < bm.bmHeight; i++ ) 
307. for ( j = 0; j < bm.bmWidth; j++ ){ 
308. // get color 
309. ismask=(dcBmp.GetPixel(j,bm.bmHeight-i-1)!=color); 
310. // place part of scan line as RECT region if transparent color found after mask color or 
311. // mask color found at the end of mask image 
312. if (wasfirst && ((ismask && (j==(bm.bmWidth-1)))||(ismask ^ (j<bm.bmWidth)))){ 
313. // get offset to RECT array if RGNDATA buffer 
314. pRects = (LPRECT)((LPBYTE)pRgnData + RDHDR); 
315. // save current RECT 
316. pRects[ pRgnData->nCount++ ] = CRect( first, bm.bmHeight - i - 1, j+(j==(bm.bmWidth-1)), bm.bmHeight - i ); 
317. // if buffer full reallocate it 
318. if ( pRgnData->nCount >= cBlocks * MAXBUF ){ 
319. LPBYTE pRgnDataNew = new BYTE[ RDHDR + ++cBlocks * MAXBUF * sizeof(RECT) ]; 
320. memcpy( pRgnDataNew, pRgnData, RDHDR + (cBlocks - 1) * MAXBUF * sizeof(RECT) ); 
321. delete pRgnData; 
322. pRgnData = (RGNDATAHEADER*)pRgnDataNew; 
323. } 
324. wasfirst = false; 
325. } else if ( !wasfirst && ismask ){ // set wasfirst when mask is found 
326. first = j; 
327. wasfirst = true; 
328. } 
329. } 
330. dcBmp.DeleteDC(); //release the bitmap 
331. // create region 
332. /* Under WinNT the ExtCreateRegion returns NULL (by Fable@aramszu.net) */ 
333. // HRGN hRgn = ExtCreateRegion( NULL, RDHDR + pRgnData->nCount * sizeof(RECT), (LPRGNDATA)pRgnData ); 
334. /* ExtCreateRegion replacement { */ 
335. HRGN hRgn=CreateRectRgn(0, 0, 0, 0); 
336. ASSERT( hRgn!=NULL ); 
337. pRects = (LPRECT)((LPBYTE)pRgnData + RDHDR); 
338. for(i=0;i<(int)pRgnData->nCount;i++) 
339. { 
340. HRGN hr=CreateRectRgn(pRects[i].left, pRects[i].top, pRects[i].right, pRects[i].bottom); 
341. VERIFY(CombineRgn(hRgn, hRgn, hr, RGN_OR)!=ERROR); 
342. if (hr) DeleteObject(hr); 
343. } 
344. ASSERT( hRgn!=NULL ); 
345. /* } ExtCreateRegion replacement */ 
347. delete pRgnData; 
348. return hRgn; 
349. } 
350. / 
351. COLORREF CXMButton::SetTextColor(COLORREF new_color) 
352. { 
353. COLORREF tmp_color=m_TextColor; 
354. m_TextColor=new_color; 
355. return tmp_color; //returns the previous color 
356. } 
357. / 
358. void CXMButton::SetToolTipText(CString s) 
359. { 
360. if(m_tooltip.m_hWnd==NULL){ 
361. if(m_tooltip.Create(this)) //first assignment 
362. if(m_tooltip.AddTool(this, (LPCTSTR)s)) 
363. m_tooltip.Activate(1); 
364. } else { 
365. m_tooltip.UpdateTipText((LPCTSTR)s,this); 
366. } 
367. } 
368. / 
369. void CXMButton::RelayEvent(UINT message, WPARAM wParam, LPARAM lParam) 
370. { 
371. // This function will create a MSG structure, fill it in a pass it to 
372. // the ToolTip control, m_ttip. Note that we ensure the point is in window 
373. // coordinates (relative to the control's window). 
374. if(NULL != m_tooltip.m_hWnd){ 
375. MSG msg; 
376. msg.hwnd = m_hWnd; 
377. msg.message = message; 
378. msg.wParam = wParam; 
379. msg.lParam = lParam; 
380. msg.time = 0; 
381. msg.pt.x = LOWORD(lParam); 
382. msg.pt.y = HIWORD(lParam); 
384. m_tooltip.RelayEvent(&msg); 
385. } 
386. } 
389. / 
390. // 
391. //Method......: OnLButtonDblClk 
392. //Class.......: CxSkinButton 
393. // 
394. //Author......: Milan Gardian 
395. //Created.....: MAR-2001 
396. // 
397. //Return value: NONE 
398. //Parameters..: Used only to be forwarded as WM_LBUTTONDOWN message parameters 
399. //Exceptions..: NONE 
400. //------------ 
401. //Description : 
402. // 
403. // > We do not care about doublelicks - handle this event 
404. // like an ordinary left-button-down event 
405. // 
406. //--------------------------------------------------------- 
407. void CXMButton::OnLButtonDblClk(UINT flags, CPoint point) 
408. { 
409. SendMessage(WM_LBUTTONDOWN, flags, MAKELPARAM(point.x, point.y)); 
410. } 
413. / 
414. // 
415. //Method......: OnLButtonDown 
416. //Class.......: CxSkinButton 
417. // 
418. //Author......: Milan Gardian 
419. //Created.....: MAR-2001 
420. // 
421. //Return value: NONE 
422. //Parameters..: As follows 
423. // > [in] nFlags: not used 
424. // > [in] point: coordinates of the mouse pointer when this event was spawned 
425. //Exceptions..: NONE 
426. //------------ 
427. //Description : 
428. // 
429. // > Handle event when left button is pressed down 
430. // 
431. //--------------------------------------------------------- 
432. void CXMButton::OnLButtonDown(UINT nFlags, CPoint point) 
433. { 
434. //TRACE("* >08X: down/n", ::GetTickCount()); 
436. //Pass this message to the ToolTip control 
437. RelayEvent(WM_LBUTTONDOWN,(WPARAM)nFlags,MAKELPARAM(LOWORD(point.x),LOWORD(point.y))); 
439. //If we are tracking this button, cancel it 
440. if (m_tracking) { 
441. TRACKMOUSEEVENT t = { 
442. sizeof(TRACKMOUSEEVENT), 
443. TME_CANCEL | TME_LEAVE, 
444. m_hWnd, 
445. 0 
446. }; 
447. if (::_TrackMouseEvent(&t)) { 
448. m_tracking = false; 
449. } 
450. } 
452. //Default-process the message 
453. CButton::OnLButtonDown(nFlags, point); 
454. m_button_down = true; 
455. } 
458. / 
459. // 
460. //Method......: OnLButtonUp 
461. //Class.......: CxSkinButton 
462. // 
463. //Author......: Milan Gardian 
464. //Created.....: MAR-2001 
465. // 
466. //Return value: NONE 
467. //Parameters..: As follows 
468. // > [in] nFlags: not used 
469. // > [in] point: coordinates of the mouse pointer when this event was spawned 
470. //Exceptions..: NONE 
471. //------------ 
472. //Description : 
473. // 
474. // > Handle event when left button is released (goes up) 
475. // 
476. //--------------------------------------------------------- 
477. void CXMButton::OnLButtonUp(UINT nFlags, CPoint point) 
478. { 
479. //TRACE("* >08X: up/n", ::GetTickCount()); 
481. if (m_Style){ //track mouse for radio & check buttons 
482. POINT p2 = point; 
483. ::ClientToScreen(m_hWnd, &p2); 
484. HWND mouse_wnd = ::WindowFromPoint(p2); 
485. if (mouse_wnd == m_hWnd){ // mouse is in button 
486. if (m_Style==BS_CHECKBOX) SetCheck(m_Checked ? 0 : 1); 
487. if (m_Style==BS_RADIOBUTTON) SetCheck(1); 
488. } 
489. } 
490. //Pass this message to the ToolTip control 
491. RelayEvent(WM_LBUTTONUP,(WPARAM)nFlags,MAKELPARAM(LOWORD(point.x),LOWORD(point.y))); 
493. //Default-process the message 
494. m_button_down = false; 
495. CButton::OnLButtonUp(nFlags, point); 
496. } 
499. / 
500. // 
501. //Method......: OnMouseMove 
502. //Class.......: CxSkinButton 
503. // 
504. //Author......: Milan Gardian 
505. //Created.....: MAR-2001 
506. // 
507. //Return value: NONE 
508. //Parameters..: As follows 
509. // > [in] nFlags: not used 
510. // > [in] point: coordinates of the mouse pointer when this event was spawned 
511. //Exceptions..: NONE 
512. //------------ 
513. //Description : 
514. // 
515. // > Handle change of mouse position: see the comments in the 
516. // method for further info. 
517. // 
518. //--------------------------------------------------------- 
519. void CXMButton::OnMouseMove(UINT nFlags, CPoint point) 
520. { 
521. //TRACE("* >08X: Mouse/n", ::GetTickCount()); 
523. //Pass this message to the ToolTip control 
524. RelayEvent(WM_MOUSEMOVE,(WPARAM)nFlags,MAKELPARAM(LOWORD(point.x),LOWORD(point.y))); 
526. //If we are in capture mode, button has been pressed down 
527. //recently and not yet released - therefore check is we are 
528. //actually over the button or somewhere else. If the mouse 
529. //position changed considerably (e.g. we moved mouse pointer 
530. //from the button to some other place outside button area) 
531. //force the control to redraw 
532. // 
533. if ((m_button_down) && (::GetCapture() == m_hWnd)) { 
534. POINT p2 = point; 
535. ::ClientToScreen(m_hWnd, &p2); 
536. HWND mouse_wnd = ::WindowFromPoint(p2); 
538. bool pressed = ((GetState() & BST_PUSHED) == BST_PUSHED); 
539. bool need_pressed = (mouse_wnd == m_hWnd); 
540. if (pressed != need_pressed) { 
541. //TRACE("* >08X Redraw/n", GetTickCount()); 
542. SetState(need_pressed ? TRUE : FALSE); 
543. Invalidate(); 
544. } 
545. } else { 
547. //Otherwise the button is released. That means we should 
548. //know when we leave its area - and so if we are not tracking 
549. //this mouse leave event yet, start now! 
550. // 
551. if (!m_tracking) { 
552. TRACKMOUSEEVENT t = { 
553. sizeof(TRACKMOUSEEVENT), 
554. TME_LEAVE, 
555. m_hWnd, 
556. 0 
557. }; 
558. if (::_TrackMouseEvent(&t)) { 
559. //TRACE("* Mouse enter/n"); 
560. m_tracking = true; 
561. Invalidate(); 
562. } 
563. } 
564. } 
566. //Forward this event to superclass 
567. CButton::OnMouseMove(nFlags, point); 
568. } 
571. / 
572. // 
573. //Method......: OnMouseLeave 
574. //Class.......: CxSkinButton 
575. // 
576. //Author......: Milan Gardian 
577. //Created.....: MAR-2001 
578. // 
579. //Return value: NULL 
580. //Parameters..: NOT USED 
581. //Exceptions..: NONE 
582. //------------ 
583. //Description : 
584. // 
585. // > Handle situation when mouse cursor leaves area of this 
586. // window (button). This event might be generated ONLY 
587. // if we explicitely call 'TrackMouseEvent'. This is 
588. // signalled by setting the m_tracking flag (see the assert 
589. // precondition) - in 'OnMouseMove' method 
590. // 
591. // > When a mouse pointer leaves area of this button (i.e. 
592. // when this method is invoked), presumably the look of 
593. // the button changes (e.g. when hover/non-hover images are set) 
594. // and therefore we force the control to redraw. 
595. // 
596. //--------------------------------------------------------- 
597. LRESULT CXMButton::OnMouseLeave(WPARAM, LPARAM) 
598. { 
599. ASSERT (m_tracking); 
600. //TRACE("* Mouse leave/n"); 
601. m_tracking = false; 
602. Invalidate(); 
603. return 0; 
604. } 
607. / 
608. // 
609. //Method......: OnKillFocus 
610. //Class.......: CxSkinButton 
611. // 
612. //Author......: Milan Gardian 
613. //Created.....: MAR-2001 
614. // 
615. //Return value: NONE 
616. //Parameters..: See superclass documentation 
617. //Exceptions..: NONE 
618. //------------ 
619. //Description : 
620. // 
621. // > If focus is killed during capture, we may no longer 
622. // have the exclusive access to user input and therefore 
623. // release it. 
624. // 
625. // > Such a situation might happens when the user left-clicks 
626. // this button, keeps the button down and simultaneously 
627. // presses TAB key. 
628. // 
629. //--------------------------------------------------------- 
630. void CXMButton::OnKillFocus(CWnd *new_wnd) 
631. { 
632. if (::GetCapture() == m_hWnd) { 
633. ::ReleaseCapture(); 
634. ASSERT (!m_tracking); 
635. m_button_down = false; 
636. } 
637. CButton::OnKillFocus(new_wnd); 
638. } 
641. / 
642. // 
643. //Method......: OnClicked 
644. //Class.......: CxSkinButton 
645. // 
646. //Author......: Milan Gardian 
647. //Created.....: MAR-2001 
648. // 
649. //Return value: FALSE (do not stop in this handler - forward to parent) 
650. //Parameters..: NONE 
651. //Exceptions..: NONE 
652. //------------ 
653. //Description : 
654. // 
655. // > Keep consistency of attributes of this instance before 
656. // submitting click event to the parent. 
657. // 
658. // > Currently NOT used. To use, umcomment line 
659. // "ON_CONTROL_REFLECT_EX(BN_CLICKED, OnClicked)" in message map 
660. // at the beginning of this file. 
661. // 
662. //--------------------------------------------------------- 
663. BOOL CXMButton::OnClicked() 
664. { 
665. if (::GetCapture() == m_hWnd) { 
666. ::ReleaseCapture(); 
667. ASSERT (!m_tracking); 
668. } 
669. m_button_down = false; 
670. //Invalidate(); 
671. return FALSE; 
672. } 
674. / 
675. // 
676. //Method......: OnRadioInfo 
677. //Class.......: CxSkinButton 
678. // 
679. //Author......: Rainer Mangold 
680. //Created.....: JUN-2001 
681. // 
682. //Return value: NULL 
683. //Parameters..: WPARAM and LPARAM (LPARAM not used) 
684. //Exceptions..: NONE 
685. //------------ 
686. //Description : 
687. // 
688. // > Handle notification, that a Button in the same group was pushed 
689. // 
690. //--------------------------------------------------------- 
691. LRESULT CXMButton::OnRadioInfo(WPARAM wparam, LPARAM) 
692. { 
693. if (m_Checked){ //only checked buttons need to be unchecked 
694. m_Checked = false; 
695. Invalidate(); 
696. } 
697. return 0; 
698. } 
699. / 
700. void CXMButton::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags) 
701. { 
702. if ((m_Style)&&(nChar==' ')){ //needed stuff for check & radio buttons 
703. if (m_Style==BS_CHECKBOX) SetCheck(m_Checked ? 0 : 1); 
704. if (m_Style==BS_RADIOBUTTON) SetCheck(1); 
705. } 
706. CButton::OnKeyDown(nChar, nRepCnt, nFlags); 
707. } 
708. / 
709. // 
710. //Method......: SetCheck 
711. //Class.......: CxSkinButton 
712. // 
713. //Author......: Rainer Mangold 
714. //Created.....: JUN-2001 
715. // 
716. //Return value: NONE 
717. //Parameters..: bool 
718. //Exceptions..: NONE 
719. //------------ 
720. //Description : 
721. // 
722. // > Set the state of this button (pushed or not). 
723. // Works for both, Radio and CheckBox - Buttons 
724. // 
725. //--------------------------------------------------------- 
726. LRESULT CXMButton::OnBMSetCheck(WPARAM wparam, LPARAM) 
727. { 
728. m_Checked=wparam!=0; 
729. switch (m_Style) 
730. { 
731. case BS_RADIOBUTTON: 
732. if (m_Checked) { //uncheck the other radio buttons (in the same group) 
733. HWND hthis,hwnd2,hpwnd; 
734. hpwnd=GetParent()->GetSafeHwnd(); //get button parent handle 
735. hwnd2=hthis=GetSafeHwnd(); //get this button handle 
736. if (hthis && hpwnd){ //consistency check 
737. for( ; ; ){ //scan the buttons within the group 
738. hwnd2=::GetNextDlgGroupItem(hpwnd,hwnd2,0); 
739. //until we reach again this button 
740. if ((hwnd2==hthis)||(hwnd2==NULL)) break; 
741. //post the uncheck message 
742. ::PostMessage(hwnd2, WM_CXSHADE_RADIO, 0, 0); 
743. } 
744. } 
745. } 
746. break; 
747. case BS_PUSHBUTTON: 
748. m_Checked=false; 
749. ASSERT(false); // Must be a Check or Radio button to use this function 
750. } 
752. Invalidate(); 
753. return 0; 
754. } 
755. / 
756. LRESULT CXMButton::OnBMGetCheck(WPARAM wparam, LPARAM) 
757. { return m_Checked; } //returns the state for check & radio buttons 
758. / 
759. //EOF 

 

m_Btncustom.SetSkin(IDB_BITMAP1,IDB_BITMAP3,IDB_BITMAP4,0,0,0,1,0,4);
 m_Btncustom.SetToolTipText("喜木自定义按扭");
 m_Btncustom.SetTextColor(RGB(255,255,255));