找回密码
 本站已关闭注册功能,有需求联系qq/微信263946146

QQ登录

只需一步，快速开始

首页 › 工控编程 › 上位机 › 上位机MFC各种定制形状按钮实例
返回列表 发新帖

上位机MFC各种定制形状按钮实例

[ 复制链接 ]
qq263946146 2019-7-3 14:59:46 显示全部楼层 阅读模式 打印 上一主题 下一主题
效果演示
例程通过自己编写按钮类实现不同形状按钮功能，效果如图：

上位机MFC各种定制形状按钮实例

上位机MFC各种定制形状按钮实例
工程实现目录内编译生成有可执行例程，可直接运行查看效果
下面代码可复制使用，也可直接下载工程源代码
请点击此处下载

请先注册会员后在进行下载

已注册会员，请先登录后下载

文件名称:CBtn.rar 
文件大小:118.11 KB  售价:10金币
下载权限: 不限 以上或 VIP会员   [购买捐助会员]   [充值积分]   有问题联系我



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

上位机MFC各种定制形状按钮实例

上位机MFC各种定制形状按钮实例
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

  5. const VTX_RECT                                = 0;
  6. const VTX_DIAMOND                        = 1;
  7. const VTX_CIRCLE                        = 2;
  8. const VTX_STRETCHEDCIRCLE        = 3;

  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);

  19. // Attributes
  20. public:
  21.         int x; // Wouldn't it be counter-productive to call this m_nX?
  22.         int y;

  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.         }

  37. // Implementation
  38. public:
  39.         virtual ~CVertex();
  40. };

  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. //

  49. class CVtxPolygons : public CObject
  50. {
  51. // Construction
  52. public:
  53.         CVtxPolygons();

  55. // Attributes
  56. private:
  57.         CObArray m_oaPolygons[4];

  59. // Operations
  60. public:
  61.         // Removes all the CVertex's from all the CObArray's:
  62.         void RemoveAll();

  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);

  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();

  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);

  86.         // Create a CRgn from the nPolygon CObArray:
  87.         void CreatePolygonRgn(CRgn *rgn, const int& nPolygon);

  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.         }

  97. // Implementation
  98. public:
  99.         virtual ~CVtxPolygons();
  100. };

  102. ///////////////////////////////////////////////////////////////////////////////////////////
复制代码
VTX.CPP

  2. #include "stdafx.h"
  3. #include "Vtx.h"
  4. #include <math.h>

  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)

  11. ///////////////////////////////////////////////////////////////////////////////////////////
  12. // CVertex object

  14. CVertex::CVertex()
  15. {
  16.         x = 0;
  17.         y = 0;
  18. }

  20. CVertex::CVertex(const CPoint& pt)
  21. {
  22.         x = pt.x;
  23.         y = pt.y;
  24. }

  26. CVertex::CVertex(const int& nX, const int& nY)
  27. {
  28.         x = nX;
  29.         y = nY;
  30. }

  32. //
  33. CVertex::CVertex(const CVertex& vtx)
  34. {
  35.         x = vtx.x;
  36.         y = vtx.y;
  37. }

  39. CVertex::~CVertex()
  40. {
  41. }

  43. ///////////////////////////////////////////////////////////////////////////////////////////
  44. // CVtxPolygons object

  46. CVtxPolygons::CVtxPolygons()
  47. {
  48. }

  50. CVtxPolygons::~CVtxPolygons()
  51. {
  52.         RemoveAll();
  53. }

  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. }

  67. int CVtxPolygons::GetSize(const int& nPolygon)
  68. {
  69.         return m_oaPolygons[nPolygon].GetSize();
  70. }

  72. CVertex *CVtxPolygons::GetAt(const int& nPolygon, const int& nVertex)
  73. {
  74.         return (CVertex*)m_oaPolygons[nPolygon].GetAt(nVertex);
  75. }

  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. }

  87. void CVtxPolygons::Add(const int& nPolygon, const CVertex& vtx)
  88. {
  89.         m_oaPolygons[nPolygon].Add(new CVertex(vtx));
  90. }

  92. void CVtxPolygons::RemoveAt(const int& nPolygon, const int& nVertex)
  93. {
  94.         m_oaPolygons[nPolygon].RemoveAt(nVertex);
  95. }

  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. }

  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. }

  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. }

  137. void CVtxPolygons::CreateRect(const CRect& rect)
  138. {
  139.         RemoveAll();

  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)};

  144.         CRect realRect = *rect;
  145.         realRect.right--;
  146.         realRect.bottom--;

  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));

  159.         }

  161.         ClosePolygons();
  162. }

  164. void CVtxPolygons::CreateDiamond(const CRect& rect)
  165. {
  166.         RemoveAll();

  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)};

  171.         CRect realRect = *rect;
  172.         realRect.right--;
  173.         realRect.bottom--;

  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.         }

  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.         }

  201.         ClosePolygons();
  202. }

  204. void CVtxPolygons::CreateCircle(const CRect& rect, const int& nSegments)
  205. {
  206.         RemoveAll();

  208.         CRect realRect = *rect;
  209.         realRect.right--;
  210.         realRect.bottom--;

  212.         double dCenterX = realRect.left + realRect.Width() / 2;
  213.         double dCenterY = realRect.top + realRect.Height() / 2;

  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.         }

  232.         double dLayers[4] = {dRadius, dRadius - 1, dRadius - 2, dRadius - 4};
  233.         int segments = (nSegments < 2 ? round(dRadius) : nSegments);

  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.         }

  247.         ClosePolygons();
  248. }

  250. void CVtxPolygons::CreateStretchedCircle(const CRect& rect, const int& nSegments)
  251. {
  252.         RemoveAll();

  254.         CRect realRect = *rect;
  255.         realRect.right--;
  256.         realRect.bottom--;

  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.         }

  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);

  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.                 }

  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.         }

  302.         ClosePolygons();
  303. }

  305. void CVtxPolygons::CreatePolygonRgn(CRgn *rgn, const int& nPolygon)
  306. {
  307.         ASSERT(ValidPolygons());

  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));

  315.         rgn->CreatePolygonRgn(pts, m_oaPolygons[nPolygon].GetSize(), ALTERNATE);       
  316. }

  318. ///////////////////////////////////////////////////////////////////////////////////////////
复制代码


VTXBUTTON.H

  2. #if _MSC_VER >= 1000
  3. #pragma once
  4. #endif // _MSC_VER >= 1000

  6. #include "Vtx.h"

  8. ///////////////////////////////////////////////////////////////////////////////////////////
  9. // CVtxButton button
  10. //
  11. // A class derived from CButton that is drawn in the shape specified by
  12. // CVtxPolygons.
  13. //

  15. class CVtxButton : public CButton
  16. {
  17. // Construction
  18. public:
  19.         CVtxButton();

  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;

  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);

  38. private:
  39.         void GenerateBitmaps(LPDRAWITEMSTRUCT lpDrawItemStruct);

  41. // Overrides
  42. public:
  43.         virtual void DrawItem(LPDRAWITEMSTRUCT lpDrawItemStruct);
  44. protected:
  45.         virtual void PreSubclassWindow();

  47. // Implementation
  48. public:
  49.         virtual ~CVtxButton();
  50. };

  52. ///////////////////////////////////////////////////////////////////////////////////////////
复制代码


VTXBUTTON.CPP
  1. #include "stdafx.h"
  2. #include "Vtx.h"
  3. #include "VtxButton.h"
  4. #include <math.h>

  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))

  13. // The angle (in radians) from which the light is from:
  14. #define LIGHT_SOURCE_ANGLE        3 * PI / 4

  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)

  21. ///////////////////////////////////////////////////////////////////////////////////////////
  22. // Misc functions

  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;

  32.         return dAngle;
  33. }

  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));

  42.         return RGB(Red, Green, Blue);
  43. }

  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. {

  50.         double dRise = (double)(ptZ.y - ptA.y);
  51.         double dRun = (double)(ptA.x - ptZ.x);
  52.         double dAngle = 2 * PI - GetAngle(dRun, dRise);

  54.         double dAngleDifference = fabs(LIGHT_SOURCE_ANGLE - dAngle);

  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. }

  61. ///////////////////////////////////////////////////////////////////////////////////////////
  62. // CVtxButton button

  64. CVtxButton::CVtxButton()
  65. {
  66.         m_pBtn = new CBitmap;
  67.         m_pBtnFocus = new CBitmap;
  68.         m_pBtnSelected = new CBitmap;
  69.         m_pBitmapDC = new CDC;

  71.         m_bNeedToRegenerateBitmaps = TRUE;
  72. }

  74. CVtxButton::~CVtxButton()
  75. {
  76.         delete m_pBitmapDC;
  77.         delete m_pBtn;
  78.         delete m_pBtnFocus;
  79.         delete m_pBtnSelected;
  80. }

  82. /////////////////////////////////////////////////////////////////////////////
  83. // CVtxButton message handlers

  85. void CVtxButton::PreSubclassWindow()
  86. {
  87.         CButton::PreSubclassWindow();

  89.         ModifyStyle(0, BS_OWNERDRAW);
  90. }

  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;

  100.         if (!m_vtxBtnPolygons.ValidPolygons())
  101.                 SetVtx(VTX_RECT);
  102.         if (m_bNeedToRegenerateBitmaps || m_dwStyle != GetStyle())
  103.                 GenerateBitmaps(lpDrawItemStruct);

  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.         }

  115.         pDC->BitBlt(0, 0, rect.Width(), rect.Height(), m_pBitmapDC, 0, 0, SRCCOPY);
  116. }

  118. ///////////////////////////////////////////////////////////////////////////////////////////
  119. // CVtxButton operations

  121. void CVtxButton::SetVtxPolygons(CVtxPolygons *vtxBtnPolygons)
  122. {
  123.         m_vtxBtnPolygons.Copy(*vtxBtnPolygons);

  125.         CRgn rgn;
  126.         m_vtxBtnPolygons.CreatePolygonRgn(&rgn, 0);
  127.        
  128.         HRGN hRgn;
  129.         hRgn = (HRGN)rgn.Detach();
  130.         SetWindowRgn(hRgn, TRUE);

  132.         m_bNeedToRegenerateBitmaps = TRUE;
  133. }

  135. void CVtxButton::SetVtx(const int& nType)
  136. {
  137.         CRect rect;
  138.         GetClientRect(rect);

  140.         m_vtxBtnPolygons.Create(&rect, nType);
  141.         CRgn rgn;
  142.         m_vtxBtnPolygons.CreatePolygonRgn(&rgn, 0);

  144.         HRGN hRgn;
  145.         hRgn = (HRGN)rgn.Detach();
  146.         SetWindowRgn(hRgn, TRUE);

  148.         m_bNeedToRegenerateBitmaps = TRUE;
  149. }

  151. ///////////////////////////////////////////////////////////////////////////////////////////
  152. // CVtxButton state bitmap generation:

  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;

  161.         m_dwStyle = GetStyle();

  163.         CRgn rgn;
  164.         m_vtxBtnPolygons.CreatePolygonRgn(&rgn, 3);

  166.         delete m_pBitmapDC;       
  167.         m_pBitmapDC = new CDC;
  168.         m_pBitmapDC->CreateCompatibleDC(pDC);
  169.         CFont *oldFont = m_pBitmapDC->SelectObject(pDC->GetCurrentFont());

  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);

  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);

  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);

  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));

  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);

  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.                 }

  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];

  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));

  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);

  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);

  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.                 }

  257.                 delete m_pBitmapDC->SelectObject(oldpen);
  258.                 delete m_pBitmapDC->SelectObject(oldBrush);
  259.         }
  260.         if (!strText.IsEmpty())
  261.         {               
  262.                 m_pBitmapDC->SelectClipRgn(&rgn);

  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.                 }

  273.                 m_pBitmapDC->SelectClipRgn(NULL);
  274.         }

  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);

  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];

  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));

  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);

  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));

  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.                 }

  324.                 COLORREF crColor = InterpolateColors(RGB_BUTTON_GRAY, RGB_BUTTON_DARK, 0.5);
  325.                 delete m_pBitmapDC->SelectObject(new CPen(PS_SOLID, 1, crColor));

  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.                 }

  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];

  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));

  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);

  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);

  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));

  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.                 }

  386.                 COLORREF crColor = InterpolateColors(RGB_BUTTON_GRAY, RGB_BUTTON_DARK, 0.5);
  387.                 delete m_pBitmapDC->SelectObject(new CPen(PS_SOLID, 1, crColor));

  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.                 }

  396.                 delete m_pBitmapDC->SelectObject(oldpen);       
  397.         }
  398.         if (!strText.IsEmpty())
  399.         {               
  400.                 m_pBitmapDC->SelectClipRgn(&rgn);

  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.                 }

  412.                 m_pBitmapDC->SelectClipRgn(NULL);
  413.         }

  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);

  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);

  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));

  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);

  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));

  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.                 }

  463.                 COLORREF crColor = InterpolateColors(RGB_BUTTON_GRAY, RGB_BUTTON_DARK, 0.5);
  464.                 delete m_pBitmapDC->SelectObject(new CPen(PS_SOLID, 1, crColor));

  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.                 }

  473.                 delete m_pBitmapDC->SelectObject(oldpen);
  474.         }
  475.         else
  476.         {
  477.                 COLORREF crBlend = InterpolateColors(RGB_BUTTON_DARK, RGB_BUTTON_BLACK, 0.5);

  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];

  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.                 }

  497.                 delete m_pBitmapDC->SelectObject(oldBrush);
  498.                 delete m_pBitmapDC->SelectObject(new CPen(PS_SOLID, 1, RGB_BUTTON_BLACK));

  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.                 }

  507.                 COLORREF crColor = InterpolateColors(RGB_BUTTON_GRAY, RGB_BUTTON_DARK, 0.5);
  508.                 delete m_pBitmapDC->SelectObject(new CPen(PS_SOLID, 1, crColor));

  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.                 }

  517.                 delete m_pBitmapDC->SelectObject(oldpen);
  518.         }
  519.         if (!strText.IsEmpty())
  520.         {               
  521.                 m_pBitmapDC->SelectClipRgn(&rgn);

  523.                 pt.Offset(1, 1);
  524.                 textRect.OffsetRect(1, 1);

  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.                 }

  536.                 m_pBitmapDC->SelectClipRgn(NULL);
  537.         }

  539.         m_pBitmapDC->SelectObject(oldFont);

  541.         m_bNeedToRegenerateBitmaps = FALSE;
  542. }

  544. ///////////////////////////////////////////////////////////////////////////////////////////
复制代码
  

如果您认可，可联系功能定制！

  

如果您着急，充值会员可直接联系发您资料！

  

QQ联系我

微信扫扫联系我

  

相关帖子
回复

使用道具 举报

qq263946146
快速回复 返回列表 客服中心 搜索