工控编程吧

标题: 上位机MFC各种定制形状按钮实例 [打印本页]

---

作者: qq263946146    时间: 2019-7-3 14:59
标题: 上位机MFC各种定制形状按钮实例
效果演示
例程通过自己编写按钮类实现不同形状按钮功能，效果如图：
(, 下载次数: 0)

上传

点击文件名下载附件
工程实现目录内编译生成有可执行例程，可直接运行查看效果
下面代码可复制使用，也可直接下载工程源代码
(, 下载次数: 0)

上传

点击文件名下载附件

实现过程
1.新建一基于对应框的工程，如界面添加按钮控件并进行排版，按钮ID依次修改为m_cButton1。。。。m_cButton12。
2.将例程根据目录四个文件VTXBUTTON.CPP，VTXBUTTON.H,VTX.H,VTX.CPP复制到自己项目根目录，
并加载到项目中。这样项目的类管理窗口就会多出三个新的类CVertex,CVTXBUTTON,CVTXPOLYGON.
(, 下载次数: 0)

上传

点击文件名下载附件
3.添加按钮对象，关联按钮控件，记得包含CVtxButton类的头文件#include "VtxButton.h"
        CVtxButton        m_cButton12;
        CVtxButton        m_cButton11;
        CVtxButton        m_cButton10;
        CVtxButton        m_cButton9;
        CVtxButton        m_cButton8;
        CVtxButton        m_cButton7;
        CVtxButton        m_cButton6;
        CVtxButton        m_cButton5;
        CVtxButton        m_cButton4;
        CVtxButton        m_cButton3;
        CVtxButton        m_cButton2;
        CVtxButton        m_cButton1;

       
       DDX_Control(pDX, IDC_BUTTON9, m_cButton9);
        DDX_Control(pDX, IDC_BUTTON8, m_cButton8);
        DDX_Control(pDX, IDC_BUTTON7, m_cButton7);
        DDX_Control(pDX, IDC_BUTTON6, m_cButton6);
        DDX_Control(pDX, IDC_BUTTON5, m_cButton5);
        DDX_Control(pDX, IDC_BUTTON12, m_cButton12);
        DDX_Control(pDX, IDC_BUTTON11, m_cButton11);
        DDX_Control(pDX, IDC_BUTTON10, m_cButton10);
        DDX_Control(pDX, IDC_BUTTON4, m_cButton4);
        DDX_Control(pDX, IDC_BUTTON3, m_cButton3);
        DDX_Control(pDX, IDC_BUTTON2, m_cButton2);
        DDX_Control(pDX, IDC_BUTTON1, m_cButton1);


4.在主对话框类的函数OnInitDialog里添加代码，初始化按钮控件类：
        CRect rect;
        m_cButton1.GetClientRect(&rect);            // Get the button's original dimensions
        CVtxPolygons vtxPolygons;
        int offset[4] = {0, 1, 2, 4};
        for (int i = 0; i < 4; i++)                 // Iterate through each of the polygons
        {
                // Add the corners
                vtxPolygons.Add(i, CVertex(rect.left + offset, rect.top + offset));
                vtxPolygons.Add(i, CVertex(rect.right - offset - 1, rect.top + offset));
                vtxPolygons.Add(i, CVertex(rect.right - offset - 1, rect.bottom - offset - 1));
                vtxPolygons.Add(i, CVertex(rect.left + offset, rect.bottom - offset - 1));
        }
        vtxPolygons.ClosePolygons();                // Close the polygons off
        m_cButton1.SetVtxPolygons(&vtxPolygons);    // Set the button's polygons

        m_cButton2.SetVtx(VTX_DIAMOND);
        m_cButton3.SetVtx(VTX_CIRCLE);
        m_cButton4.SetVtx(VTX_STRETCHEDCIRCLE);

        m_cButton5.SetVtx(VTX_RECT);
        m_cButton6.SetVtx(VTX_DIAMOND);
        m_cButton7.SetVtx(VTX_CIRCLE);
        m_cButton8.SetVtx(VTX_STRETCHEDCIRCLE);

        m_cButton9.SetVtx(VTX_RECT);
        m_cButton10.SetVtx(VTX_DIAMOND);
        m_cButton11.SetVtx(VTX_CIRCLE);
        m_cButton12.SetVtx(VTX_STRETCHEDCIRCLE);

5.这样各种形状按钮就可以编译支持起来查看效果了。
下面是四个文件的代码，可以复制使用
VTE.H

1. #if _MSC_VER >= 1000
   
2. #pragma once
   
3. #endif // _MSC_VER >= 1000
   
4. 
   
5. const VTX_RECT                                = 0;
   
6. const VTX_DIAMOND                        = 1;
   
7. const VTX_CIRCLE                        = 2;
   
8. const VTX_STRETCHEDCIRCLE        = 3;
   
9. 
   
10. class CVertex : public CObject
    
11. {
    
12. // Construction
    
13. public:
    
14.         CVertex();
    
15.         CVertex(const CPoint& pt);
    
16.         CVertex(const int& nX, const int& nY);
    
17.         CVertex(const CVertex& vtx);
    
18. 
    
19. // Attributes
    
20. public:
    
21.         int x; // Wouldn't it be counter-productive to call this m_nX?
    
22.         int y;
    
23. 
    
24. // Operations
    
25. public:
    
26.         operator CPoint()
    
27.         {
    
28.                 return CPoint(x, y);
    
29.         }
    
30.         operator!=(const CVertex& right)
    
31.         {
    
32.                 if (x == right.x && y == right.y)
    
33.                         return FALSE;
    
34.                 return TRUE;
    
35.         }
    
36. 
    
37. // Implementation
    
38. public:
    
39.         virtual ~CVertex();
    
40. };
    
41. 
    
42. ///////////////////////////////////////////////////////////////////////////////////////////
    
43. // CVtxPolygons object
    
44. //
    
45. // A container class specifically designed for use in a CVtxButton. It contains an array of
    
46. // four CObArray's. Each CObArray is a list of CVertex's which define a polygon.
    
47. //
    
48. 
    
49. class CVtxPolygons : public CObject
    
50. {
    
51. // Construction
    
52. public:
    
53.         CVtxPolygons();
    
54. 
    
55. // Attributes
    
56. private:
    
57.         CObArray m_oaPolygons[4];
    
58. 
    
59. // Operations
    
60. public:
    
61.         // Removes all the CVertex's from all the CObArray's:
    
62.         void RemoveAll();
    
63. 
    
64.         // Functions that are specific to the nPolygon CObArray:
    
65.         int GetSize(const int& nPolygon);
    
66.         CVertex *GetAt(const int& nPolygon, const int& nVertex);
    
67.         void SetAt(const int& nPolygon, const int& nVertex, const CVertex& vtx);
    
68.         void InsertAt(const int& nPolygon, const int& nVertex, const CVertex& vtx);
    
69.         void Add(const int& nPolygon, const CVertex& vtx);
    
70.         void RemoveAt(const int& nPolygon, const int& nVertex);
    
71. 
    
72.         // Returns true if each CObArray contains at least one CVertex and
    
73.         // contains the same number of CVertex's as each of the other CObArray's:
    
74.         BOOL ValidPolygons();
    
75.         // If the last CVertex in a CObArray is not the same as the first,
    
76.         // this function will add a CVertex to the end that is the same:
    
77.         void ClosePolygons();
    
78. 
    
79.         // Create standard shape functions:
    
80.         void Create(const CRect& rect, const int& nType = VTX_RECT);
    
81.         void CreateRect(const CRect& rect);
    
82.         void CreateDiamond(const CRect& rect);
    
83.         void CreateCircle(const CRect& rect, const int& nSegments = 0);
    
84.         void CreateStretchedCircle(const CRect& rect, const int& nSegments = 0);
    
85. 
    
86.         // Create a CRgn from the nPolygon CObArray:
    
87.         void CreatePolygonRgn(CRgn *rgn, const int& nPolygon);
    
88. 
    
89.         void Copy(const CVtxPolygons& vtxBtnPolygons)
    
90.         {
    
91.                 RemoveAll();
    
92.                 for (int i = 0; i < 4; i++)
    
93.                         for (int j = 0; j < vtxBtnPolygons.m_oaPolygons[i].GetSize(); j++)
    
94.                                 Add(i, *(CVertex*)vtxBtnPolygons.m_oaPolygons[i].GetAt(j));
    
95.         }
    
96. 
    
97. // Implementation
    
98. public:
    
99.         virtual ~CVtxPolygons();
    
100. };
     
101. 
     
102. ///////////////////////////////////////////////////////////////////////////////////////////

复制代码

VTX.CPP

1. 
   
2. #include "stdafx.h"
   
3. #include "Vtx.h"
   
4. #include <math.h>
   
5. 
   
6. // There is no excuse for inaccuracy in this area =)
   
7. #define PI                        3.1415926535897932384626433832795028841971693993751058209
   
8. // A very convenient way to properly convert double's to int's:
   
9. #define round(x)        (int)(x + 0.5)
   
10. 
    
11. ///////////////////////////////////////////////////////////////////////////////////////////
    
12. // CVertex object
    
13. 
    
14. CVertex::CVertex()
    
15. {
    
16.         x = 0;
    
17.         y = 0;
    
18. }
    
19. 
    
20. CVertex::CVertex(const CPoint& pt)
    
21. {
    
22.         x = pt.x;
    
23.         y = pt.y;
    
24. }
    
25. 
    
26. CVertex::CVertex(const int& nX, const int& nY)
    
27. {
    
28.         x = nX;
    
29.         y = nY;
    
30. }
    
31. 
    
32. //
    
33. CVertex::CVertex(const CVertex& vtx)
    
34. {
    
35.         x = vtx.x;
    
36.         y = vtx.y;
    
37. }
    
38. 
    
39. CVertex::~CVertex()
    
40. {
    
41. }
    
42. 
    
43. ///////////////////////////////////////////////////////////////////////////////////////////
    
44. // CVtxPolygons object
    
45. 
    
46. CVtxPolygons::CVtxPolygons()
    
47. {
    
48. }
    
49. 
    
50. CVtxPolygons::~CVtxPolygons()
    
51. {
    
52.         RemoveAll();
    
53. }
    
54. 
    
55. void CVtxPolygons::RemoveAll()
    
56. {
    
57.         for (int i = 0; i < 4; i++)
    
58.         {
    
59.                 for (int j = 0; j < m_oaPolygons[i].GetSize(); j++)
    
60.                 {
    
61.                         if (m_oaPolygons[i].GetAt(j) != NULL)
    
62.                                 delete m_oaPolygons[i].GetAt(j);
    
63.                 }
    
64.         }
    
65. }
    
66. 
    
67. int CVtxPolygons::GetSize(const int& nPolygon)
    
68. {
    
69.         return m_oaPolygons[nPolygon].GetSize();
    
70. }
    
71. 
    
72. CVertex *CVtxPolygons::GetAt(const int& nPolygon, const int& nVertex)
    
73. {
    
74.         return (CVertex*)m_oaPolygons[nPolygon].GetAt(nVertex);
    
75. }
    
76. 
    
77. void CVtxPolygons::SetAt(const int& nPolygon, const int& nVertex, const CVertex& vtx)
    
78. {
    
79.         m_oaPolygons[nPolygon].SetAt(nVertex, new CVertex(vtx));
    
80. }
    
81.        
    
82. void CVtxPolygons::InsertAt(const int& nPolygon, const int& nVertex, const CVertex& vtx)
    
83. {
    
84.         m_oaPolygons[nPolygon].InsertAt(nVertex, new CVertex(vtx));
    
85. }
    
86. 
    
87. void CVtxPolygons::Add(const int& nPolygon, const CVertex& vtx)
    
88. {
    
89.         m_oaPolygons[nPolygon].Add(new CVertex(vtx));
    
90. }
    
91. 
    
92. void CVtxPolygons::RemoveAt(const int& nPolygon, const int& nVertex)
    
93. {
    
94.         m_oaPolygons[nPolygon].RemoveAt(nVertex);
    
95. }
    
96. 
    
97. BOOL CVtxPolygons::ValidPolygons()
    
98. {
    
99.         int nSize = GetSize(0);
    
100.         if (nSize == 0)
     
101.                 return FALSE;
     
102.         if (nSize != GetSize(1))
     
103.                 return FALSE;
     
104.         if (nSize != GetSize(2))
     
105.                 return FALSE;
     
106.         if (nSize != GetSize(3))
     
107.                 return FALSE;
     
108.         return TRUE;
     
109. }
     
110. 
     
111. void CVtxPolygons::ClosePolygons()
     
112. {
     
113.         for (int i = 0; i < 4; i++)
     
114.                 if (*GetAt(i, GetSize(i) - 1) != *GetAt(i, 0))
     
115.                         Add(i, *GetAt(i, 0));
     
116. }
     
117. 
     
118. void CVtxPolygons::Create(const CRect& rect, const int& nType)
     
119. {
     
120.         switch (nType)
     
121.         {
     
122.                 case VTX_RECT:
     
123.                         CreateRect(rect);
     
124.                         break;
     
125.                 case VTX_DIAMOND:
     
126.                         CreateDiamond(rect);
     
127.                         break;
     
128.                 case VTX_CIRCLE:
     
129.                         CreateCircle(rect);
     
130.                         break;
     
131.                 case VTX_STRETCHEDCIRCLE:
     
132.                         CreateStretchedCircle(rect);
     
133.                         break;
     
134.         }
     
135. }
     
136. 
     
137. void CVtxPolygons::CreateRect(const CRect& rect)
     
138. {
     
139.         RemoveAll();
     
140. 
     
141.         CRect offset[4] = {CRect(0, 0, 0, 0), CRect(1, 1, -1, -1),
     
142.                 CRect(2, 2, -2, -2), CRect(4, 4, -4, -4)};
     
143. 
     
144.         CRect realRect = *rect;
     
145.         realRect.right--;
     
146.         realRect.bottom--;
     
147. 
     
148.         for (int i = 0; i < 4; i++)
     
149.         {
     
150.                 m_oaPolygons[i].Add(new CVertex(realRect.left + offset[i].left,
     
151.                         realRect.top + offset[i].top));
     
152.                 m_oaPolygons[i].Add(new CVertex(realRect.right + offset[i].right,
     
153.                         realRect.top + offset[i].top));
     
154.                 m_oaPolygons[i].Add(new CVertex(realRect.right + offset[i].right,
     
155.                         realRect.bottom + offset[i].bottom));
     
156.                 m_oaPolygons[i].Add(new CVertex(realRect.left + offset[i].left,
     
157.                         realRect.bottom + offset[i].bottom));
     
158. 
     
159.         }
     
160. 
     
161.         ClosePolygons();
     
162. }
     
163. 
     
164. void CVtxPolygons::CreateDiamond(const CRect& rect)
     
165. {
     
166.         RemoveAll();
     
167. 
     
168.         CRect offset[4] = {CRect(0, 0, 0, 0), CRect(1, 1, -1, -1),
     
169.                 CRect(2, 2, -2, -2), CRect(4, 4, -4, -4)};
     
170. 
     
171.         CRect realRect = *rect;
     
172.         realRect.right--;
     
173.         realRect.bottom--;
     
174. 
     
175.         UINT side;
     
176.         if (realRect.right > realRect.bottom)
     
177.         {
     
178.                 side = realRect.bottom;
     
179.                 realRect.left = round((realRect.right - side) / 2);
     
180.                 realRect.right = realRect.left + side;
     
181.         }
     
182.         else
     
183.         {
     
184.                 side = realRect.right;
     
185.                 realRect.top = round((realRect.bottom - side) / 2);
     
186.                 realRect.bottom = realRect.top + side;
     
187.         }
     
188. 
     
189.         for (UINT i = 0; i < 4; i++)
     
190.         {
     
191.                 m_oaPolygons[i].Add(new CVertex(realRect.left + offset[i].left,
     
192.                         round(realRect.top + realRect.Height() / 2)));
     
193.                 m_oaPolygons[i].Add(new CVertex(round(realRect.left + realRect.Width() / 2),
     
194.                         realRect.top + offset[i].top));
     
195.                 m_oaPolygons[i].Add(new CVertex(realRect.right + offset[i].right,
     
196.                         round(realRect.top + realRect.Height() / 2)));
     
197.                 m_oaPolygons[i].Add(new CVertex(round(realRect.left + realRect.Width() / 2),
     
198.                         realRect.bottom + offset[i].bottom));
     
199.         }
     
200. 
     
201.         ClosePolygons();
     
202. }
     
203. 
     
204. void CVtxPolygons::CreateCircle(const CRect& rect, const int& nSegments)
     
205. {
     
206.         RemoveAll();
     
207. 
     
208.         CRect realRect = *rect;
     
209.         realRect.right--;
     
210.         realRect.bottom--;
     
211. 
     
212.         double dCenterX = realRect.left + realRect.Width() / 2;
     
213.         double dCenterY = realRect.top + realRect.Height() / 2;
     
214. 
     
215.         UINT nSide;
     
216.         double dRadius;
     
217.         if (realRect.right > realRect.bottom)
     
218.         {
     
219.                 nSide = realRect.bottom;
     
220.                 realRect.left = round((realRect.right - nSide) / 2);
     
221.                 realRect.right = realRect.left + nSide;
     
222.                 dRadius = dCenterY;
     
223.         }
     
224.         else
     
225.         {
     
226.                 nSide = realRect.right;
     
227.                 realRect.top = round((realRect.bottom - nSide) / 2);
     
228.                 realRect.bottom = realRect.top + nSide;
     
229.                 dRadius = dCenterX;
     
230.         }
     
231. 
     
232.         double dLayers[4] = {dRadius, dRadius - 1, dRadius - 2, dRadius - 4};
     
233.         int segments = (nSegments < 2 ? round(dRadius) : nSegments);
     
234. 
     
235.         double dAngle;
     
236.         for (int i = 0; i < 4; i++)
     
237.         {
     
238.                 m_oaPolygons[i].RemoveAll();
     
239.                 for (int j = 0; j < segments; j++)
     
240.                 {
     
241.                         dAngle = 2.0 * PI * j / segments;
     
242.                         m_oaPolygons[i].Add(new CVertex(round(dCenterX + cos(dAngle) * dLayers[i]),
     
243.                                 round(dCenterY + sin(dAngle) * dLayers[i])));
     
244.                 }
     
245.         }
     
246. 
     
247.         ClosePolygons();
     
248. }
     
249. 
     
250. void CVtxPolygons::CreateStretchedCircle(const CRect& rect, const int& nSegments)
     
251. {
     
252.         RemoveAll();
     
253. 
     
254.         CRect realRect = *rect;
     
255.         realRect.right--;
     
256.         realRect.bottom--;
     
257. 
     
258.         double dRadius;
     
259.         double dRightX, dRightY;
     
260.         double dStartAngle;
     
261.         BOOL bHorizontal = realRect.right > realRect.bottom;
     
262.         if (bHorizontal)
     
263.         {
     
264.                 dRadius = realRect.top + realRect.Height() / 2;
     
265.                 dRightX = realRect.right - dRadius;
     
266.                 dRightY = dRadius;
     
267.                 dStartAngle = 3 * PI / 2;
     
268.         }
     
269.         else
     
270.         {
     
271.                 dRadius = realRect.left + realRect.Width() / 2;
     
272.                 dRightX = dRadius;
     
273.                 dRightY = realRect.bottom - dRadius;
     
274.                 dStartAngle = 0;
     
275.         }
     
276. 
     
277.         double dLeftX = dRadius;
     
278.         double dLeftY = dRadius;
     
279.        
     
280.         double dRadiusLayers[4] = {dRadius, dRadius - 1, dRadius - 2, dRadius - 4};
     
281.         int segments = (nSegments < 1 ? round(dRadius) : nSegments);
     
282. 
     
283.         double dAngle;
     
284.         for (int i = 0; i < 4; i++)
     
285.         {
     
286.                 m_oaPolygons[i].RemoveAll();
     
287.                 for (int j = 0; j < round(segments / 2 + 1); j++)
     
288.                 {
     
289.                         dAngle = dStartAngle + 2 * PI * j / segments;
     
290.                         m_oaPolygons[i].Add(new CVertex(round(dRightX + cos(dAngle) *
     
291.                                 dRadiusLayers[i]), round(dRightY + sin(dAngle) * dRadiusLayers[i])));
     
292.                 }
     
293. 
     
294.                 for (j = round(segments / 2); j < segments + 1; j++)
     
295.                 {
     
296.                         dAngle = dStartAngle + 2 * PI * j / segments;
     
297.                         m_oaPolygons[i].Add(new CVertex(round(dLeftX + cos(dAngle) *
     
298.                                 dRadiusLayers[i]), round(dLeftY + sin(dAngle)  *dRadiusLayers[i])));
     
299.                 }
     
300.         }
     
301. 
     
302.         ClosePolygons();
     
303. }
     
304. 
     
305. void CVtxPolygons::CreatePolygonRgn(CRgn *rgn, const int& nPolygon)
     
306. {
     
307.         ASSERT(ValidPolygons());
     
308. 
     
309.         ClosePolygons();
     
310.        
     
311.         CPoint pts[1024];
     
312.         for (int i = 0; i < m_oaPolygons[nPolygon].GetSize(); i++)
     
313.                 pts[i] = (CPoint)(*(CVertex*)m_oaPolygons[nPolygon].GetAt(i));
     
314. 
     
315.         rgn->CreatePolygonRgn(pts, m_oaPolygons[nPolygon].GetSize(), ALTERNATE);       
     
316. }
     
317. 
     
318. ///////////////////////////////////////////////////////////////////////////////////////////

复制代码

VTXBUTTON.H

1. 
   
2. #if _MSC_VER >= 1000
   
3. #pragma once
   
4. #endif // _MSC_VER >= 1000
   
5. 
   
6. #include "Vtx.h"
   
7. 
   
8. ///////////////////////////////////////////////////////////////////////////////////////////
   
9. // CVtxButton button
   
10. //
    
11. // A class derived from CButton that is drawn in the shape specified by
    
12. // CVtxPolygons.
    
13. //
    
14. 
    
15. class CVtxButton : public CButton
    
16. {
    
17. // Construction
    
18. public:
    
19.         CVtxButton();
    
20. 
    
21. // Attributes
    
22. private:
    
23.         CVtxPolygons        m_vtxBtnPolygons;
    
24.         CDC                                *m_pBitmapDC;
    
25.         CBitmap                        *m_pBtn,
    
26.                                         *m_pBtnFocus,
    
27.                                         *m_pBtnSelected;
    
28.         DWORD                        m_dwStyle;
    
29.         BOOL                        m_bNeedToRegenerateBitmaps;
    
30. 
    
31. // Operations
    
32. public:
    
33.         // Select a custom CVtxPolygons shape:
    
34.         void SetVtxPolygons(CVtxPolygons *vtxBtnPolygons);
    
35.         // Select a standard CVtxPolygons shape:
    
36.         void SetVtx(const int& nType);
    
37. 
    
38. private:
    
39.         void GenerateBitmaps(LPDRAWITEMSTRUCT lpDrawItemStruct);
    
40. 
    
41. // Overrides
    
42. public:
    
43.         virtual void DrawItem(LPDRAWITEMSTRUCT lpDrawItemStruct);
    
44. protected:
    
45.         virtual void PreSubclassWindow();
    
46. 
    
47. // Implementation
    
48. public:
    
49.         virtual ~CVtxButton();
    
50. };
    
51. 
    
52. ///////////////////////////////////////////////////////////////////////////////////////////

复制代码

VTXBUTTON.CPP

1. #include "stdafx.h"
   
2. #include "Vtx.h"
   
3. #include "VtxButton.h"
   
4. #include <math.h>
   
5. 
   
6. // Windows system colors:
   
7. #define RGB_BUTTON_BLACK        (GetSysColor(COLOR_3DDKSHADOW))
   
8. #define RGB_BUTTON_WHITE        (GetSysColor(COLOR_3DHILIGHT))
   
9. #define RGB_BUTTON_GRAY                (GetSysColor(COLOR_3DFACE))
   
10. #define RGB_BUTTON_LIGHT        (GetSysColor(COLOR_3DLIGHT))
    
11. #define RGB_BUTTON_DARK                (GetSysColor(COLOR_3DSHADOW))
    
12. 
    
13. // The angle (in radians) from which the light is from:
    
14. #define LIGHT_SOURCE_ANGLE        3 * PI / 4
    
15. 
    
16. // There is no excuse for inaccuracy in this area =)
    
17. #define PI                        3.1415926535897932384626433832795028841971693993751058209
    
18. // A very convenient way to properly convert double's to int's:
    
19. #define round(x)        (int)(x + 0.5)
    
20. 
    
21. ///////////////////////////////////////////////////////////////////////////////////////////
    
22. // Misc functions
    
23. 
    
24. // Compute the angle of a line segment given it's rise and run:
    
25. double GetAngle(const double& dRise, const double& dRun)
    
26. {
    
27.         double dAngle = atan2(dRise, dRun);
    
28.        
    
29.         if (dAngle < 0.0)
    
30.                 dAngle = 2 * PI + dAngle;
    
31. 
    
32.         return dAngle;
    
33. }
    
34. 
    
35. // Compute an intermediate color:
    
36. COLORREF InterpolateColors(const COLORREF& crA, const COLORREF& crB, const double& dWeight)
    
37. {
    
38.         BYTE Red   = (BYTE)(dWeight * GetRValue(crA) + (1.0 - dWeight) * GetRValue(crB));
    
39.         BYTE Green = (BYTE)(dWeight * GetGValue(crA) + (1.0 - dWeight) * GetGValue(crB));
    
40.         BYTE Blue  = (BYTE)(dWeight * GetBValue(crA) + (1.0 - dWeight) * GetBValue(crB));
    
41. 
    
42.         return RGB(Red, Green, Blue);
    
43. }
    
44. 
    
45. // Compute the color of a line segment defined by ptA and ptB:
    
46. COLORREF GetColor(const CPoint& ptA, const CPoint& ptZ, const COLORREF& crDark,
    
47.                                   const COLORREF& crBright)
    
48. {
    
49. 
    
50.         double dRise = (double)(ptZ.y - ptA.y);
    
51.         double dRun = (double)(ptA.x - ptZ.x);
    
52.         double dAngle = 2 * PI - GetAngle(dRun, dRise);
    
53. 
    
54.         double dAngleDifference = fabs(LIGHT_SOURCE_ANGLE - dAngle);
    
55. 
    
56.         // I blatantly took this code fragment, "0.5 * (cos(dAngleDifference) + 1.0)," from  
    
57.         // Chris Maunder because it works. I am at a loss as to why.
    
58.         return InterpolateColors(crBright, crDark, 0.5 * (cos(dAngleDifference) + 1.0));
    
59. }
    
60. 
    
61. ///////////////////////////////////////////////////////////////////////////////////////////
    
62. // CVtxButton button
    
63. 
    
64. CVtxButton::CVtxButton()
    
65. {
    
66.         m_pBtn = new CBitmap;
    
67.         m_pBtnFocus = new CBitmap;
    
68.         m_pBtnSelected = new CBitmap;
    
69.         m_pBitmapDC = new CDC;
    
70. 
    
71.         m_bNeedToRegenerateBitmaps = TRUE;
    
72. }
    
73. 
    
74. CVtxButton::~CVtxButton()
    
75. {
    
76.         delete m_pBitmapDC;
    
77.         delete m_pBtn;
    
78.         delete m_pBtnFocus;
    
79.         delete m_pBtnSelected;
    
80. }
    
81. 
    
82. /////////////////////////////////////////////////////////////////////////////
    
83. // CVtxButton message handlers
    
84. 
    
85. void CVtxButton::PreSubclassWindow()
    
86. {
    
87.         CButton::PreSubclassWindow();
    
88. 
    
89.         ModifyStyle(0, BS_OWNERDRAW);
    
90. }
    
91. 
    
92. // Paint the button with the correct bitmap:
    
93. void CVtxButton::DrawItem(LPDRAWITEMSTRUCT lpDrawItemStruct)
    
94. {
    
95.         ASSERT(lpDrawItemStruct != NULL);
    
96.         CDC *pDC = CDC::FromHandle(lpDrawItemStruct->hDC);
    
97.         CRect rect = lpDrawItemStruct->rcItem;
    
98.         UINT state = lpDrawItemStruct->itemState;
    
99. 
    
100.         if (!m_vtxBtnPolygons.ValidPolygons())
     
101.                 SetVtx(VTX_RECT);
     
102.         if (m_bNeedToRegenerateBitmaps || m_dwStyle != GetStyle())
     
103.                 GenerateBitmaps(lpDrawItemStruct);
     
104. 
     
105.         if (state & ODS_SELECTED)
     
106.                 m_pBitmapDC->SelectObject(m_pBtnSelected);
     
107.         else
     
108.         {
     
109.                 if (state & ODS_FOCUS)
     
110.                         m_pBitmapDC->SelectObject(m_pBtnFocus);
     
111.                 else
     
112.                         m_pBitmapDC->SelectObject(m_pBtn);
     
113.         }
     
114. 
     
115.         pDC->BitBlt(0, 0, rect.Width(), rect.Height(), m_pBitmapDC, 0, 0, SRCCOPY);
     
116. }
     
117. 
     
118. ///////////////////////////////////////////////////////////////////////////////////////////
     
119. // CVtxButton operations
     
120. 
     
121. void CVtxButton::SetVtxPolygons(CVtxPolygons *vtxBtnPolygons)
     
122. {
     
123.         m_vtxBtnPolygons.Copy(*vtxBtnPolygons);
     
124. 
     
125.         CRgn rgn;
     
126.         m_vtxBtnPolygons.CreatePolygonRgn(&rgn, 0);
     
127.        
     
128.         HRGN hRgn;
     
129.         hRgn = (HRGN)rgn.Detach();
     
130.         SetWindowRgn(hRgn, TRUE);
     
131. 
     
132.         m_bNeedToRegenerateBitmaps = TRUE;
     
133. }
     
134. 
     
135. void CVtxButton::SetVtx(const int& nType)
     
136. {
     
137.         CRect rect;
     
138.         GetClientRect(rect);
     
139. 
     
140.         m_vtxBtnPolygons.Create(&rect, nType);
     
141.         CRgn rgn;
     
142.         m_vtxBtnPolygons.CreatePolygonRgn(&rgn, 0);
     
143. 
     
144.         HRGN hRgn;
     
145.         hRgn = (HRGN)rgn.Detach();
     
146.         SetWindowRgn(hRgn, TRUE);
     
147. 
     
148.         m_bNeedToRegenerateBitmaps = TRUE;
     
149. }
     
150. 
     
151. ///////////////////////////////////////////////////////////////////////////////////////////
     
152. // CVtxButton state bitmap generation:
     
153. 
     
154. void CVtxButton::GenerateBitmaps(LPDRAWITEMSTRUCT lpDrawItemStruct)
     
155. {
     
156.         ASSERT(lpDrawItemStruct != NULL);
     
157.         CDC *pDC = CDC::FromHandle(lpDrawItemStruct->hDC);
     
158.         CRect rect = lpDrawItemStruct->rcItem;
     
159.         UINT state = lpDrawItemStruct->itemState;
     
160. 
     
161.         m_dwStyle = GetStyle();
     
162. 
     
163.         CRgn rgn;
     
164.         m_vtxBtnPolygons.CreatePolygonRgn(&rgn, 3);
     
165. 
     
166.         delete m_pBitmapDC;       
     
167.         m_pBitmapDC = new CDC;
     
168.         m_pBitmapDC->CreateCompatibleDC(pDC);
     
169.         CFont *oldFont = m_pBitmapDC->SelectObject(pDC->GetCurrentFont());
     
170. 
     
171.         CString        strText;
     
172.         GetWindowText(strText);
     
173.         CSize        extent = m_pBitmapDC->GetTextExtent(strText);
     
174.         CPoint        ptCenter = rect.CenterPoint();
     
175.         CPoint        pt = CPoint(ptCenter.x - extent.cx / 2 - 1, ptCenter.y - extent.cy / 2 - 1);
     
176.         CRect        textRect(pt.x, pt.y, pt.x + extent.cx, pt.y + extent.cy);
     
177. 
     
178.         delete m_pBtn;
     
179.         m_pBtn = new CBitmap;
     
180.         m_pBtn->CreateCompatibleBitmap(pDC, rect.right, rect.bottom);
     
181.         m_pBitmapDC->SelectObject(m_pBtn);
     
182.         m_pBitmapDC->SelectStockObject(NULL_BRUSH);
     
183.         m_pBitmapDC->FillSolidRect(rect, RGB_BUTTON_GRAY);
     
184. 
     
185.         // Generate m_pBtn bitmap: unfocused button
     
186.         if (m_dwStyle & BS_FLAT)
     
187.         {
     
188.                 COLORREF crBlend = InterpolateColors(RGB_BUTTON_WHITE, RGB_BUTTON_BLACK, 0.5);
     
189. 
     
190.                 CPen *oldpen = m_pBitmapDC->SelectObject(new CPen(PS_SOLID, 1, RGB_BUTTON_GRAY));
     
191.                 CBrush *oldBrush = m_pBitmapDC->SelectObject(new CBrush(crBlend));
     
192.                 CPoint pts[4];
     
193.                
     
194.                 for (int i = 0; i < m_vtxBtnPolygons.GetSize(0) - 1; i++)
     
195.                 {
     
196.                         pts[2] = CPoint(*m_vtxBtnPolygons.GetAt(0, i + 1));
     
197.                         pts[3] = CPoint(*m_vtxBtnPolygons.GetAt(0, i));
     
198. 
     
199.                         delete m_pBitmapDC->SelectObject(new CBrush(crBlend));
     
200.                         delete m_pBitmapDC->SelectObject(new CPen(PS_SOLID, 1, crBlend));
     
201.                         pts[0] = CPoint(*m_vtxBtnPolygons.GetAt(1, i));
     
202.                         pts[1] = CPoint(*m_vtxBtnPolygons.GetAt(1, i + 1));
     
203.                         m_pBitmapDC->Polygon(pts, 4);
     
204.                         delete m_pBitmapDC->SelectObject(new CPen(PS_SOLID, 1, RGB_BUTTON_WHITE));
     
205.                         m_pBitmapDC->MoveTo(*m_vtxBtnPolygons.GetAt(1, i + 1));
     
206.                         m_pBitmapDC->LineTo(*m_vtxBtnPolygons.GetAt(1, i));
     
207.                         m_pBitmapDC->SetPixelV(*m_vtxBtnPolygons.GetAt(1, i), RGB_BUTTON_WHITE);
     
208. 
     
209.                         delete m_pBitmapDC->SelectObject(new CPen(PS_SOLID, 1, RGB_BUTTON_BLACK));
     
210.                         m_pBitmapDC->MoveTo(*m_vtxBtnPolygons.GetAt(0, i + 1));
     
211.                         m_pBitmapDC->LineTo(*m_vtxBtnPolygons.GetAt(0, i));
     
212.                         m_pBitmapDC->SetPixelV(*m_vtxBtnPolygons.GetAt(0, i), RGB_BUTTON_BLACK);
     
213.                 }
     
214. 
     
215.                 delete m_pBitmapDC->SelectObject(oldpen);
     
216.                 delete m_pBitmapDC->SelectObject(oldBrush);
     
217.         }
     
218.         else
     
219.         {
     
220.                 CPen *oldpen = m_pBitmapDC->SelectObject(new CPen(PS_SOLID, 1, RGB_BUTTON_GRAY));
     
221.                 CBrush *oldBrush = m_pBitmapDC->SelectObject(new CBrush(RGB_BUTTON_GRAY));
     
222.                 CPoint pts[4];
     
223. 
     
224.                 COLORREF crLighter = RGB_BUTTON_LIGHT;
     
225.                 COLORREF crDarker = RGB_BUTTON_DARK;
     
226.                 COLORREF crBlend = RGB_BUTTON_GRAY;
     
227.                
     
228.                 for (int i = 0; i < m_vtxBtnPolygons.GetSize(0) - 1; i++)
     
229.                 {
     
230.                         pts[2] = CPoint(*m_vtxBtnPolygons.GetAt(0, i + 1));
     
231.                         pts[3] = CPoint(*m_vtxBtnPolygons.GetAt(0, i));
     
232. 
     
233.                         crLighter = GetColor(*m_vtxBtnPolygons.GetAt(1, i),
     
234.                                 *m_vtxBtnPolygons.GetAt(1, i + 1), RGB_BUTTON_DARK,
     
235.                                 RGB_BUTTON_LIGHT);
     
236.                         crDarker = GetColor(*m_vtxBtnPolygons.GetAt(0, i),
     
237.                                 *m_vtxBtnPolygons.GetAt(0, i + 1), RGB_BUTTON_BLACK,
     
238.                                 RGB_BUTTON_WHITE);
     
239.                         crBlend = InterpolateColors(crLighter, crDarker, 0.5);
     
240. 
     
241.                         delete m_pBitmapDC->SelectObject(new CBrush(crBlend));
     
242.                         delete m_pBitmapDC->SelectObject(new CPen(PS_SOLID, 1, crBlend));
     
243.                         pts[0] = CPoint(*m_vtxBtnPolygons.GetAt(1, i));
     
244.                         pts[1] = CPoint(*m_vtxBtnPolygons.GetAt(1, i + 1));
     
245.                         m_pBitmapDC->Polygon(pts, 4);
     
246.                         delete m_pBitmapDC->SelectObject(new CPen(PS_SOLID, 1, crLighter));
     
247.                         m_pBitmapDC->MoveTo(*m_vtxBtnPolygons.GetAt(1, i + 1));
     
248.                         m_pBitmapDC->LineTo(*m_vtxBtnPolygons.GetAt(1, i));
     
249.                         m_pBitmapDC->SetPixelV(*m_vtxBtnPolygons.GetAt(1, i), crLighter);
     
250. 
     
251.                         delete m_pBitmapDC->SelectObject(new CPen(PS_SOLID, 1, crDarker));
     
252.                         pts[0] = CPoint(*m_vtxBtnPolygons.GetAt(0, i));
     
253.                         pts[1] = CPoint(*m_vtxBtnPolygons.GetAt(0, i + 1));
     
254.                         m_pBitmapDC->Polygon(pts, 4);
     
255.                 }
     
256. 
     
257.                 delete m_pBitmapDC->SelectObject(oldpen);
     
258.                 delete m_pBitmapDC->SelectObject(oldBrush);
     
259.         }
     
260.         if (!strText.IsEmpty())
     
261.         {               
     
262.                 m_pBitmapDC->SelectClipRgn(&rgn);
     
263. 
     
264.                 m_pBitmapDC->SetBkMode(TRANSPARENT);
     
265.                 if (state & ODS_DISABLED)
     
266.                         m_pBitmapDC->DrawState(pt, extent, strText, DSS_DISABLED, TRUE, 0, (HBRUSH)NULL);
     
267.                 else
     
268.                 {
     
269.                         m_pBitmapDC->DrawText(strText, -1, textRect, DT_SINGLELINE | DT_CENTER |
     
270.                                 DT_VCENTER);
     
271.                 }
     
272. 
     
273.                 m_pBitmapDC->SelectClipRgn(NULL);
     
274.         }
     
275. 
     
276.         delete m_pBtnFocus;
     
277.         m_pBtnFocus = new CBitmap;
     
278.         m_pBtnFocus->CreateCompatibleBitmap(pDC, rect.right, rect.bottom);
     
279.         m_pBitmapDC->SelectObject(m_pBtnFocus);
     
280.         m_pBitmapDC->SelectStockObject(NULL_BRUSH);
     
281.         m_pBitmapDC->FillSolidRect(rect, RGB_BUTTON_GRAY);
     
282. 
     
283.         // Generate m_pBtnFocus bitmap: focused button
     
284.         if (m_dwStyle & BS_FLAT)
     
285.         {
     
286.                 CPen *oldpen = m_pBitmapDC->SelectObject(new CPen(PS_SOLID, 1, RGB_BUTTON_GRAY));
     
287.                 CBrush *oldBrush = m_pBitmapDC->SelectObject(new CBrush(RGB_BUTTON_GRAY));
     
288.                 CPoint pts[4];
     
289. 
     
290.                 COLORREF crBlend = InterpolateColors(RGB_BUTTON_WHITE, RGB_BUTTON_BLACK, 0.5);
     
291.                
     
292.                 for (int i = 0; i < m_vtxBtnPolygons.GetSize(0) - 1; i++)
     
293.                 {
     
294.                         pts[2] = CPoint(*m_vtxBtnPolygons.GetAt(0, i + 1));
     
295.                         pts[3] = CPoint(*m_vtxBtnPolygons.GetAt(0, i));
     
296. 
     
297.                         delete m_pBitmapDC->SelectObject(new CBrush(crBlend));
     
298.                         delete m_pBitmapDC->SelectObject(new CPen(PS_SOLID, 1, crBlend));
     
299.                         pts[0] = CPoint(*m_vtxBtnPolygons.GetAt(2, i));
     
300.                         pts[1] = CPoint(*m_vtxBtnPolygons.GetAt(2, i + 1));
     
301.                         m_pBitmapDC->Polygon(pts, 4);
     
302.                         delete m_pBitmapDC->SelectObject(new CPen(PS_SOLID, 1, RGB_BUTTON_WHITE));
     
303.                         m_pBitmapDC->MoveTo(*m_vtxBtnPolygons.GetAt(2, i + 1));
     
304.                         m_pBitmapDC->LineTo(*m_vtxBtnPolygons.GetAt(2, i));
     
305.                         m_pBitmapDC->SetPixelV(*m_vtxBtnPolygons.GetAt(2, i), RGB_BUTTON_WHITE);
     
306. 
     
307.                         delete m_pBitmapDC->SelectObject(new CBrush(RGB_BUTTON_BLACK));
     
308.                         delete m_pBitmapDC->SelectObject(new CPen(PS_SOLID, 1, RGB_BUTTON_BLACK));
     
309.                         pts[0] = CPoint(*m_vtxBtnPolygons.GetAt(1, i));
     
310.                         pts[1] = CPoint(*m_vtxBtnPolygons.GetAt(1, i + 1));
     
311.                         m_pBitmapDC->Polygon(pts, 4);
     
312.                 }
     
313.                
     
314.                 delete m_pBitmapDC->SelectObject(oldBrush);
     
315.                 delete m_pBitmapDC->SelectObject(new CPen(PS_SOLID, 1, RGB_BUTTON_BLACK));
     
316. 
     
317.                 for (i = 0; i < m_vtxBtnPolygons.GetSize(0) - 1; i++)
     
318.                 {
     
319.                         m_pBitmapDC->MoveTo(*m_vtxBtnPolygons.GetAt(0, i + 1));
     
320.                         m_pBitmapDC->LineTo(*m_vtxBtnPolygons.GetAt(0, i));
     
321.                         m_pBitmapDC->SetPixelV(*m_vtxBtnPolygons.GetAt(0, i), RGB_BUTTON_BLACK);
     
322.                 }
     
323. 
     
324.                 COLORREF crColor = InterpolateColors(RGB_BUTTON_GRAY, RGB_BUTTON_DARK, 0.5);
     
325.                 delete m_pBitmapDC->SelectObject(new CPen(PS_SOLID, 1, crColor));
     
326. 
     
327.                 for (i = 0; i < m_vtxBtnPolygons.GetSize(0) - 1; i++)
     
328.                 {
     
329.                         m_pBitmapDC->MoveTo(*m_vtxBtnPolygons.GetAt(3, i + 1));
     
330.                         m_pBitmapDC->LineTo(*m_vtxBtnPolygons.GetAt(3, i));
     
331.                         m_pBitmapDC->SetPixelV(*m_vtxBtnPolygons.GetAt(3, i), crColor);
     
332.                 }
     
333. 
     
334.                 delete m_pBitmapDC->SelectObject(oldpen);       
     
335.         }
     
336.         else
     
337.         {
     
338.                 CPen *oldpen = m_pBitmapDC->SelectObject(new CPen(PS_SOLID, 1, RGB_BUTTON_GRAY));
     
339.                 CBrush *oldBrush = m_pBitmapDC->SelectObject(new CBrush(RGB_BUTTON_GRAY));
     
340.                 CPoint pts[4];
     
341. 
     
342.                 COLORREF crLighter = RGB_BUTTON_LIGHT;
     
343.                 COLORREF crDarker = RGB_BUTTON_DARK;
     
344.                 COLORREF crBlend = RGB_BUTTON_GRAY;
     
345.                
     
346.                 for (int i = 0; i < m_vtxBtnPolygons.GetSize(0) - 1; i++)
     
347.                 {
     
348.                         pts[2] = CPoint(*m_vtxBtnPolygons.GetAt(0, i + 1));
     
349.                         pts[3] = CPoint(*m_vtxBtnPolygons.GetAt(0, i));
     
350. 
     
351.                         crLighter = GetColor(*m_vtxBtnPolygons.GetAt(2, i),
     
352.                                 *m_vtxBtnPolygons.GetAt(2, i + 1), RGB_BUTTON_DARK,
     
353.                                 RGB_BUTTON_LIGHT);
     
354.                         crDarker = GetColor(*m_vtxBtnPolygons.GetAt(1, i),
     
355.                                 *m_vtxBtnPolygons.GetAt(1, i + 1), RGB_BUTTON_BLACK,
     
356.                                 RGB_BUTTON_WHITE);
     
357.                         crBlend = InterpolateColors(crLighter, crDarker, 0.5);
     
358. 
     
359.                         delete m_pBitmapDC->SelectObject(new CBrush(crBlend));
     
360.                         delete m_pBitmapDC->SelectObject(new CPen(PS_SOLID, 1, crBlend));       
     
361.                         pts[0] = CPoint(*m_vtxBtnPolygons.GetAt(2, i));
     
362.                         pts[1] = CPoint(*m_vtxBtnPolygons.GetAt(2, i + 1));
     
363.                         m_pBitmapDC->Polygon(pts, 4);
     
364.                         delete m_pBitmapDC->SelectObject(new CPen(PS_SOLID, 1, crLighter));
     
365.                         m_pBitmapDC->MoveTo(*m_vtxBtnPolygons.GetAt(2, i + 1));
     
366.                         m_pBitmapDC->LineTo(*m_vtxBtnPolygons.GetAt(2, i));
     
367.                         m_pBitmapDC->SetPixelV(*m_vtxBtnPolygons.GetAt(2, i), crLighter);
     
368. 
     
369.                         delete m_pBitmapDC->SelectObject(new CBrush(crDarker));
     
370.                         delete m_pBitmapDC->SelectObject(new CPen(PS_SOLID, 1, crDarker));
     
371.                         pts[0] = CPoint(*m_vtxBtnPolygons.GetAt(1, i));
     
372.                         pts[1] = CPoint(*m_vtxBtnPolygons.GetAt(1, i + 1));
     
373.                         m_pBitmapDC->Polygon(pts, 4);
     
374.                 }
     
375.                
     
376.                 delete m_pBitmapDC->SelectObject(oldBrush);
     
377.                 delete m_pBitmapDC->SelectObject(new CPen(PS_SOLID, 1, RGB_BUTTON_BLACK));
     
378. 
     
379.                 for (i = 0; i < m_vtxBtnPolygons.GetSize(0) - 1; i++)
     
380.                 {
     
381.                         m_pBitmapDC->MoveTo(*m_vtxBtnPolygons.GetAt(0, i + 1));
     
382.                         m_pBitmapDC->LineTo(*m_vtxBtnPolygons.GetAt(0, i));
     
383.                         m_pBitmapDC->SetPixelV(*m_vtxBtnPolygons.GetAt(0, i), RGB_BUTTON_BLACK);
     
384.                 }
     
385. 
     
386.                 COLORREF crColor = InterpolateColors(RGB_BUTTON_GRAY, RGB_BUTTON_DARK, 0.5);
     
387.                 delete m_pBitmapDC->SelectObject(new CPen(PS_SOLID, 1, crColor));
     
388. 
     
389.                 for (i = 0; i < m_vtxBtnPolygons.GetSize(0) - 1; i++)
     
390.                 {
     
391.                         m_pBitmapDC->MoveTo(*m_vtxBtnPolygons.GetAt(3, i + 1));
     
392.                         m_pBitmapDC->LineTo(*m_vtxBtnPolygons.GetAt(3, i));
     
393.                         m_pBitmapDC->SetPixelV(*m_vtxBtnPolygons.GetAt(3, i), crColor);
     
394.                 }
     
395. 
     
396.                 delete m_pBitmapDC->SelectObject(oldpen);       
     
397.         }
     
398.         if (!strText.IsEmpty())
     
399.         {               
     
400.                 m_pBitmapDC->SelectClipRgn(&rgn);
     
401. 
     
402.                 m_pBitmapDC->SetBkMode(TRANSPARENT);
     
403.                 if (state & ODS_DISABLED)
     
404.                         m_pBitmapDC->DrawState(pt, extent, strText, DSS_DISABLED, TRUE, 0,
     
405.                         (HBRUSH)NULL);
     
406.                 else
     
407.                 {
     
408.                         m_pBitmapDC->DrawText(strText, -1, textRect, DT_SINGLELINE | DT_CENTER |
     
409.                                 DT_VCENTER);
     
410.                 }
     
411. 
     
412.                 m_pBitmapDC->SelectClipRgn(NULL);
     
413.         }
     
414. 
     
415.         delete m_pBtnSelected;
     
416.         m_pBtnSelected = new CBitmap;
     
417.         m_pBtnSelected->CreateCompatibleBitmap(pDC, rect.right, rect.bottom);
     
418.         m_pBitmapDC->SelectObject(m_pBtnSelected);
     
419.         m_pBitmapDC->SelectStockObject(NULL_BRUSH);
     
420.         m_pBitmapDC->FillSolidRect(rect, RGB_BUTTON_GRAY);
     
421. 
     
422.         // Generate m_pBtnSelected bitmap: selected button
     
423.         if (m_dwStyle & BS_FLAT)
     
424.         {
     
425.                 COLORREF crBlend = InterpolateColors(RGB_BUTTON_DARK, RGB_BUTTON_BLACK, 0.5);
     
426. 
     
427.                 CPen *oldpen = m_pBitmapDC->SelectObject(new CPen(PS_SOLID, 1, RGB_BUTTON_GRAY));
     
428.                 CBrush *oldBrush = m_pBitmapDC->SelectObject(new CBrush(RGB_BUTTON_GRAY));
     
429.                 CPoint pts[4];
     
430.                
     
431.                 for (int i = 0; i < m_vtxBtnPolygons.GetSize(0) - 1; i++)
     
432.                 {
     
433.                         pts[2] = CPoint(*m_vtxBtnPolygons.GetAt(0, i + 1));
     
434.                         pts[3] = CPoint(*m_vtxBtnPolygons.GetAt(0, i));
     
435. 
     
436.                         delete m_pBitmapDC->SelectObject(new CBrush(crBlend));
     
437.                         delete m_pBitmapDC->SelectObject(new CPen(PS_SOLID, 1, crBlend));
     
438.                         pts[0] = CPoint(*m_vtxBtnPolygons.GetAt(2, i));
     
439.                         pts[1] = CPoint(*m_vtxBtnPolygons.GetAt(2, i + 1));
     
440.                         m_pBitmapDC->Polygon(pts, 4);
     
441.                         delete m_pBitmapDC->SelectObject(new CPen(PS_SOLID, 1, RGB_BUTTON_WHITE));
     
442.                         m_pBitmapDC->MoveTo(*m_vtxBtnPolygons.GetAt(2, i + 1));
     
443.                         m_pBitmapDC->LineTo(*m_vtxBtnPolygons.GetAt(2, i));
     
444.                         m_pBitmapDC->SetPixelV(*m_vtxBtnPolygons.GetAt(2, i), RGB_BUTTON_WHITE);
     
445. 
     
446.                         delete m_pBitmapDC->SelectObject(new CBrush(RGB_BUTTON_BLACK));
     
447.                         delete m_pBitmapDC->SelectObject(new CPen(PS_SOLID, 1, RGB_BUTTON_BLACK));
     
448.                         pts[0] = CPoint(*m_vtxBtnPolygons.GetAt(1, i));
     
449.                         pts[1] = CPoint(*m_vtxBtnPolygons.GetAt(1, i + 1));
     
450.                         m_pBitmapDC->Polygon(pts, 4);
     
451.                 }
     
452.                
     
453.                 delete m_pBitmapDC->SelectObject(oldBrush);
     
454.                 delete m_pBitmapDC->SelectObject(new CPen(PS_SOLID, 1, RGB_BUTTON_BLACK));
     
455. 
     
456.                 for (i = 0; i < m_vtxBtnPolygons.GetSize(0) - 1; i++)
     
457.                 {
     
458.                         m_pBitmapDC->MoveTo(*m_vtxBtnPolygons.GetAt(0, i + 1));
     
459.                         m_pBitmapDC->LineTo(*m_vtxBtnPolygons.GetAt(0, i));
     
460.                         m_pBitmapDC->SetPixelV(*m_vtxBtnPolygons.GetAt(0, i), RGB_BUTTON_BLACK);
     
461.                 }
     
462. 
     
463.                 COLORREF crColor = InterpolateColors(RGB_BUTTON_GRAY, RGB_BUTTON_DARK, 0.5);
     
464.                 delete m_pBitmapDC->SelectObject(new CPen(PS_SOLID, 1, crColor));
     
465. 
     
466.                 for (i = 0; i < m_vtxBtnPolygons.GetSize(0) - 1; i++)
     
467.                 {
     
468.                         m_pBitmapDC->MoveTo(*m_vtxBtnPolygons.GetAt(3, i + 1));
     
469.                         m_pBitmapDC->LineTo(*m_vtxBtnPolygons.GetAt(3, i));
     
470.                         m_pBitmapDC->SetPixelV(*m_vtxBtnPolygons.GetAt(3, i), crColor);
     
471.                 }
     
472. 
     
473.                 delete m_pBitmapDC->SelectObject(oldpen);
     
474.         }
     
475.         else
     
476.         {
     
477.                 COLORREF crBlend = InterpolateColors(RGB_BUTTON_DARK, RGB_BUTTON_BLACK, 0.5);
     
478. 
     
479.                 CPen *oldpen = m_pBitmapDC->SelectObject(new CPen(PS_SOLID, 1, RGB_BUTTON_DARK));
     
480.                 CBrush *oldBrush = m_pBitmapDC->SelectObject(new CBrush(crBlend));
     
481.                 CPoint pts[4];
     
482. 
     
483.                 for (int i = 0; i < m_vtxBtnPolygons.GetSize(0) - 1; i++)
     
484.                 {
     
485.                         delete m_pBitmapDC->SelectObject(new CPen(PS_SOLID, 1, crBlend));
     
486.                         pts[0] = CPoint(*m_vtxBtnPolygons.GetAt(1, i));
     
487.                         pts[1] = CPoint(*m_vtxBtnPolygons.GetAt(1, i + 1));
     
488.                         pts[2] = CPoint(*m_vtxBtnPolygons.GetAt(0, i + 1));
     
489.                         pts[3] = CPoint(*m_vtxBtnPolygons.GetAt(0, i));
     
490.                         m_pBitmapDC->Polygon(pts, 4);
     
491.                         delete m_pBitmapDC->SelectObject(new CPen(PS_SOLID, 1, RGB_BUTTON_DARK));
     
492.                         m_pBitmapDC->MoveTo(*m_vtxBtnPolygons.GetAt(1, i + 1));
     
493.                         m_pBitmapDC->LineTo(*m_vtxBtnPolygons.GetAt(1, i));
     
494.                         m_pBitmapDC->SetPixelV(*m_vtxBtnPolygons.GetAt(1, i), RGB_BUTTON_DARK);
     
495.                 }
     
496. 
     
497.                 delete m_pBitmapDC->SelectObject(oldBrush);
     
498.                 delete m_pBitmapDC->SelectObject(new CPen(PS_SOLID, 1, RGB_BUTTON_BLACK));
     
499. 
     
500.                 for (i = 0; i < m_vtxBtnPolygons.GetSize(0) - 1; i++)
     
501.                 {
     
502.                         m_pBitmapDC->MoveTo(*m_vtxBtnPolygons.GetAt(0, i + 1));
     
503.                         m_pBitmapDC->LineTo(*m_vtxBtnPolygons.GetAt(0, i));
     
504.                         m_pBitmapDC->SetPixelV(*m_vtxBtnPolygons.GetAt(0, i), RGB_BUTTON_BLACK);
     
505.                 }
     
506. 
     
507.                 COLORREF crColor = InterpolateColors(RGB_BUTTON_GRAY, RGB_BUTTON_DARK, 0.5);
     
508.                 delete m_pBitmapDC->SelectObject(new CPen(PS_SOLID, 1, crColor));
     
509. 
     
510.                 for (i = 0; i < m_vtxBtnPolygons.GetSize(0) - 1; i++)
     
511.                 {
     
512.                         m_pBitmapDC->MoveTo(*m_vtxBtnPolygons.GetAt(3, i + 1));
     
513.                         m_pBitmapDC->LineTo(*m_vtxBtnPolygons.GetAt(3, i));
     
514.                         m_pBitmapDC->SetPixelV(*m_vtxBtnPolygons.GetAt(3, i), crColor);
     
515.                 }
     
516. 
     
517.                 delete m_pBitmapDC->SelectObject(oldpen);
     
518.         }
     
519.         if (!strText.IsEmpty())
     
520.         {               
     
521.                 m_pBitmapDC->SelectClipRgn(&rgn);
     
522. 
     
523.                 pt.Offset(1, 1);
     
524.                 textRect.OffsetRect(1, 1);
     
525. 
     
526.                 m_pBitmapDC->SetBkMode(TRANSPARENT);
     
527.                 if (state & ODS_DISABLED)
     
528.                         m_pBitmapDC->DrawState(pt, extent, strText, DSS_DISABLED, TRUE, 0,
     
529.                         (HBRUSH)NULL);
     
530.                 else
     
531.                 {
     
532.                         m_pBitmapDC->DrawText(strText, -1, textRect, DT_SINGLELINE | DT_CENTER |
     
533.                                 DT_VCENTER);
     
534.                 }
     
535. 
     
536.                 m_pBitmapDC->SelectClipRgn(NULL);
     
537.         }
     
538. 
     
539.         m_pBitmapDC->SelectObject(oldFont);
     
540. 
     
541.         m_bNeedToRegenerateBitmaps = FALSE;
     
542. }
     
543. 
     
544. ///////////////////////////////////////////////////////////////////////////////////////////

复制代码

[weixinlianxi]1[/weixinlianxi]

---

欢迎光临 工控编程吧 (https://www.gkbc8.com/)

Powered by Discuz! X3.4