DUI中的函数说明

最新推荐文章于 2022-01-17 21:41:27 发布
最新推荐文章于 2022-01-17 21:41:27 发布
阅读量1.4k 收藏 2
点赞数 2
分类专栏： Duilib

过年有些耽搁，深感抱歉。

近日依旧在进行客户端界面使用DirectUI 进行尝试，由于一切控件均需要进行自绘，过程较为耗时。

 

控件的实现由CUIBaseCtrl基类开始

定义如下：

 

[cpp] view plain copy print ?
  1. /* CLASS_BEGIN ***************************************************** 
  2.    类名：CUIBaseCtrl 
  3.    功能：控件基类 
  4.    CLASS_END  ******************************************************/  
  5. #ifndef H_CUIBASECTRL_H  
  6. #define H_CUIBASECTRL_H  
  7. #include "CTypeDef.h"  
  8. #include "UIRenderEngine.h"  
  9. #include "UICache.h"  
  10. #include "UIStructDef.h"  
  11. #include "BinarySet.h"  
  12.   
  13. enum e_CheckBordType  
  14. {  
  15.     e_bIsWorkRange = 0,                             // 选中工作区域  
  16.     e_bIsCkLBorder,                                 // 选中左边框  
  17.     e_bIsCkRBorder,                                 // 选中右边框  
  18.     e_bIsCkTBorder,                                 // 选中上边框  
  19.     e_bIsCkBBorder,                                 // 选中上边框  
  20.     e_bIsCkLTBorder,                                // 选中左顶点  
  21.     e_bIsCkRTBorder,                                // 选中右顶点  
  22.     e_bIsCkLBBorder,                                // 选中上底点  
  23.     e_bIsCkRBBorder,                                // 选中上底点  
  24. };  
  25.   
  26. class CWinWnd;  
  27. // 控件基类  
  28. class CUIBaseCtrl  
  29. {  
  30. public:  
  31.     CUIBaseCtrl(CUICache* apCache, CWinWnd* ahWnd);  
  32.     ~CUIBaseCtrl(void);  
  33.   
  34.   
  35.     void    SetVisiable(BOOL abIsVisiable);                                         // 设置是否可见  
  36.     BOOL    GetVisiable(void);                                                      // 获取是否可见  
  37.   
  38.     void    SetCtrlID(ULong aulCtrlID);                                             // 设置控件ID  
  39.     ULong   GetCtrlID(void);                                                        // 获取控件ID  
  40.     HWND    GetWnd(void);                                                           // 获取窗口   
  41.     HINSTANCE GetInstance(void);  
  42.   
  43.     int     GetFont(void) {return m_iFont;}                                         // 获取窗口   
  44.     int     SetFont(int aiFont) {m_iFont = aiFont;}                                 // 获取窗口   
  45.   
  46.     void    SetRect(RECT& aoRect);                                                  // 设置控件所在矩形区域  
  47.     void    SetRect(int aiXVertex, int aiYVertex, int aiWidth, int aiHeight);       // 设置控件所在矩形区域  
  48.     void    SetBordeRect(void);                                                     // 设置边框矩形  
  49.     RECT&   GetRect(void);                                                          // 获取控件所在矩形区域  
  50.   
  51.     int     GetWidth(void);                                                         // 获取控件宽度  
  52.     int     GetHeight(void);                                                        // 获取控件高度  
  53.     int     GetXVertex(void);                                                       // 获取顶点X  
  54.     int     GetYVertex(void);                                                       // 获取顶点Y  
  55.   
  56.     void    SetBorderSize(int aiBorderSize);                                        // 设置控件边框  
  57.     int     GetBorderSize(void);                                                    // 获取控件边框  
  58.     void    SetBorderRound(SIZE asBorderRound);                                     // 设置控件圆角  
  59.     SIZE    GetBorderRound(void);                                                   // 获取控件圆角  
  60.   
  61.     void    SetWndRound(int aiRound);                                               // 设置窗体圆角  
  62.     int     GetWndRound(void);                                                      // 获取窗体圆角  
  63.   
  64.     void    SetData(unsigned char*);                                                // 设置控件数据  
  65.     UInt8*  GetData(void) const;                                                    // 获取控件数据  
  66.   
  67.     void    SetMaxSize(BOOL abIsMaxSize);                                           // 设置窗口是否最大化  
  68.     BOOL    GetMaxSize(void);                                                       // 获取窗口是否最大化  
  69.   
  70.     BOOL    AddChildCtrl(CUIBaseCtrl*);                                             // 增加子控件  
  71.     BOOL    DelChildCtrl(CUIBaseCtrl*);                                             // 删除子控件  
  72.   
  73.     BOOL    SetParentCtrl(CUIBaseCtrl*);                                            // 设置父控件  
  74.     CUIBaseCtrl*    GetParentCtrl(void);                                            // 获取父控件  
  75.   
  76.     void    SetBkColor(ULong aulBkColor);                                           // 设置背景色  
  77.     ULong   GetBkColor(void);                                                       // 获取背景色  
  78.     void    SetBkImage(TCHAR* apImageName);                                         // 获取背图片  
  79.     TCHAR*  GetBkImage(void);                                                       // 设置背图片  
  80.   
  81.     void    SetStatusImage(TCHAR* apImageName);  
  82.     CStdString& GetStatusImage(void);                                                 
  83.     BOOL    DrawImage(HDC hDC, TCHAR* apImageName, LPCTSTR pStrModify = NULL, int aiNarrow = 0);        // 绘制图片  
  84.     void    Invalidate(void);                                                       // 更新  
  85.   
  86.     void    SetFocus(BOOL abIsFocus);                                               // 是否选中  
  87.   
  88.     RECT&   GetWorkRect(void);                                                      // 获取工作区域矩形  
  89.     BOOL    IsPtInCtrlRect(POINT& );                                                // 坐标是否在控件区域内  
  90.     BOOL    IsPtInWorkRect(POINT&);                                                 // 坐标是否在工作区域内  
  91.     BOOL    IsPtInLRect(POINT&);                                                    // 坐标是否左边框内  
  92.     BOOL    IsPtInRRect(POINT&);                                                    // 坐标是否右边框内  
  93.     BOOL    IsPtInTRect(POINT&);                                                    // 坐标是否上边框内  
  94.     BOOL    IsPtInBRect(POINT&);                                                    // 坐标是否下边框内  
  95.     BOOL    IsPtInLTRect(POINT&);                                                   // 坐标是否左顶点  
  96.     BOOL    IsPtInRTRect(POINT&);                                                   // 坐标是否右顶点  
  97.     BOOL    IsPtInLBRect(POINT&);                                                   // 坐标是否上底点  
  98.     BOOL    IsPtInRBRect(POINT&);                                                   // 坐标是否下底点  
  99.     void    OnBReSize(int aiYBefore, int aiYAfter, RECT& aoRedressRect,             // 下边框重新计算  
  100.                       RECT& aoParentRect, int aiBorderSize);  
  101.     void    OnTReSize(int aiYBefore, int aiYAfter, RECT& aoRedressRect,             // 上边框重新计算  
  102.                       RECT& aoParentRect, int aiBorderSize);  
  103.     void    OnRReSize(int aiXBefore, int aiXAfter, RECT& aoRedressRect,             // 右边框重新计算  
  104.                       RECT& aoParentRect, int aiBorderSize);  
  105.     void    OnLReSize(int aiXBefore, int aiXAfter, RECT& aoRedressRect,             // 左边框重新计算  
  106.                       RECT& aoParentRect, int aiBorderSize);  
  107.   
  108.     CUIBaseCtrl* FindCtrl(POINT& aoPoint);                                          // 找到指定坐标所属的子窗口  
  109.     CUIBaseCtrl* GetTopCtrl(void);                                                  // 获得底层控件  
  110.   
  111.   
  112.     void    SetTestMouseHit(BOOL abMouseHit)        {m_bTestMouseHit = abMouseHit;}     //   
  113.     BOOL    GetTestMouseHit(void)                   {return m_bTestMouseHit;}  
  114.       
  115.     void    SetTestMouseLeave(BOOL abMouseLeave)    {m_bTestMouseLeave = abMouseLeave;}  
  116.     BOOL    GetTestMouseLeave(void)                 {return m_bTestMouseLeave;}  
  117.   
  118.     // 设置处理消息回调函数  
  119.     BOOL    SetMsgCallBack(ULong aulMsgId, MsgCallBack apFunc);  
  120.     // 获取窗口的最大化 还原等属性  
  121.     int     GetStytle(void);  
  122.   
  123.     void SetPrintBkColor(BOOL abIsdrawBkCol)        { m_bPrntBkColor        = abIsdrawBkCol ;}  
  124.     void SetPrintBkImage(BOOL abPrntBkImage)        { m_bPrntBkImage        = abPrntBkImage ;}  
  125.     void SetPrintStImage(BOOL abPrntGdiplusImage)   { m_bPrntGdiPlusImage   = abPrntGdiplusImage ;}  
  126.     void SetPrintText(BOOL abPrntText)              { m_bPrntText           = abPrntText ;}  
  127.     void SetPrintBorder(BOOL abPrntBorder)          { m_bPrntBorder         = abPrntBorder ;}  
  128.   
  129.     CStdString& GetWndText(void)                    { return m_strWinText;}  
  130.     void SetWndText(TCHAR* apText);  
  131.   
  132.     //设置文字风格  
  133.     void SetTextStyle(ULong aulTextStyle) { m_ulTextStyle = aulTextStyle ;}  
  134.     virtual void OnPaint(HDC ahDC, const RECT& aoRect, S_MsgEventUI& apEvent);      // 绘制控件  
  135.   
  136. // 消息处理  
  137. protected:  
  138.     friend class CMSGMgr;  
  139.       
  140.     virtual void PaintBkColor(HDC ahDC);                                            // 绘制背景  
  141.     virtual void PaintBkImage(HDC ahDC);                                            // 绘制背景图片  
  142.     virtual void PaintGdiplusImage(HDC hDC);                                        // 绘制状态图  
  143.     virtual void PaintText(HDC hDC);                                                // 绘制文字  
  144.     virtual void PaintBorder(HDC hDC);                                              // 绘制边框  
  145.     virtual void PaintMoveBorder(HDC hDC);                                          // 绘制运动边框  
  146.     virtual void PaintChangeSize(HDC hDC);                                          // 绘制大小改变  
  147.   
  148.     virtual void OnSize(S_MsgEventUI& apEvent);                                     // 大小改变时  
  149.   
  150.     virtual void OnCtrlMsg(S_MsgEventUI& apEvent);                                  // 控件消息分派  
  151.     virtual void OnLButtonDown(S_MsgEventUI& apEvent);                              // 当鼠标左键落下  
  152.     virtual void OnLButtonUP(S_MsgEventUI& apEvent);                                // 当鼠标左键弹起时  
  153.     virtual void OnLBuDbClk(S_MsgEventUI& apEvent);                                 // 当鼠标左键双击  
  154.   
  155.     virtual void OnRButtonDown(S_MsgEventUI& apEvent);                              // 当鼠标右键落下  
  156.     virtual void OnRButtonUP(S_MsgEventUI& apEvent);                                // 当鼠标右键弹起时  
  157.     virtual void OnRBuDbClk(S_MsgEventUI& apEvent);                                 // 当鼠标右键双击  
  158.   
  159.     virtual void OnMouseMove(S_MsgEventUI& apEvent);                                // 鼠标移动到  
  160.     virtual void OnMouseHover(S_MsgEventUI& apEvent);                               // 鼠标停留  
  161.     virtual void OnMouseHit(S_MsgEventUI& apEvent);                                 // 鼠标撞击  
  162.     virtual void OnMouseLeave(S_MsgEventUI& apEvent);                               // 鼠标移动到  
  163.     virtual void OnKillFocus(S_MsgEventUI& apEvent);                                // 失去焦点  
  164.     virtual void OnCtrlBroadcast(S_MsgEventUI& apEvent);                            // 控件广播消息  
  165.     virtual void OnMaxRestore(void);                                                // 设置窗口的最大化和恢复  
  166.   
  167.     virtual void OnOCMCommand(S_MsgEventUI& apEvent);  
  168.   
  169. // 动作  
  170. protected:  
  171.     // 平移控件  
  172.     virtual void MoveChildWindow(int aiXMove, int aiYMove);                         // 移动子窗口  
  173.     virtual void BegMoveWindow(POINT& aoPtMouse);                                   // 开始移动窗口  
  174.     virtual void EndMoveWindow(POINT& aoPtMouse);                                   // 结束移动窗口  
  175.     virtual void DrawMoveRect(POINT& aoPtMouse);                                    // 绘制移动时区域  
  176.     virtual void DrawChangeRect(POINT& aoPtMouse);                                  // 绘制变化时区域  
  177.   
  178.     // 改变控件大小  
  179.     virtual void BegSizeChange(POINT& aoPtMouse);                                   // 开始改变  
  180.     virtual void EndSizeChange(POINT& aoPtMouse);                                   // 结束改变  
  181.     virtual void IsChMouseOnBorder(POINT& aoPtMouse);                               // 测试鼠标是否边框上  
  182. protected:  
  183.     CWinWnd*                        m_hWinWnd;                                        
  184.     ULong                           m_ulCtrlID;                                     // 控件ID  
  185.     HWND                            m_hWnd;  
  186.     CUICache*                       m_pUIResCache;                                  // 界面资源缓冲  
  187.     UInt8*                          m_pData;                                        // 控件关联数据  
  188.   
  189.     RECT                            m_oRect;                                        // 当前控件所在的区域  
  190.     RECT                            m_oWockRect;                                    // 工作区域  
  191.     RECT                            m_oRectPrint;                                   // 相交矩形部分     
  192.     RECT                            m_oMovingRect;                                  // 移动矩形  
  193.     RECT                            m_oSCUpDateRect;                                // 大小改变时更新区域  
  194.   
  195.     RECT                            m_oBordeLRect;                                  // 左边框矩形  
  196.     RECT                            m_oBordeRRect;                                  // 右边框矩形  
  197.     RECT                            m_oBordeTRect;                                  // 上边框矩形  
  198.     RECT                            m_oBordeBRect;                                  // 下边框矩形  
  199.     RECT                            m_oBordeLTRect;                                 // 左顶点  
  200.     RECT                            m_oBordeRTRect;                                 // 右顶点  
  201.     RECT                            m_oBordeLBRect;                                 // 左底点  
  202.     RECT                            m_oBordeRBRect;                                 // 右底点  
  203.   
  204.     CUIBaseCtrl*                    m_pParentCtrl;                                  // 父控件  
  205.     TBinarySet<CUIBaseCtrl*>      m_pChildCtrlSet;                                // 子控件  
  206.     CThreadLock                     m_oChildCtrlSetLock;                            // 子控件锁  
  207.   
  208.     BOOL                            m_bColorHSL;                                    // 色调(H)、饱和度(S)、亮度(L)    
  209.     BOOL                            m_bIsFocus;                                     // 是否选中  
  210.     BOOL                            m_bTestMouseHit;                                // 鼠标是否在控件上  
  211.     BOOL                            m_bTestMouseLeave;                              // 鼠标是否在控件上  
  212.   
  213.     ULong                           m_ulBkColor;                                    // 背景色  
  214.     TCHAR*                          m_pBkImage;                                     // 背景图片描述  
  215.     CStdString                      m_oStatusImage;                                 // 状态图片描述  
  216.     int                             m_iBorderSize;                                  // 边框大小  
  217.   
  218.     SIZE                            m_cxyBorderRound;                               // 边框圆角  
  219.     int                             m_iRound;                                       // 窗体圆角  
  220.     ULong                           m_ulNomalBordecCl;                              // 常规边框颜色  
  221.     ULong                           m_ulFocusBordecCl;                              // 焦点边框颜色  
  222.   
  223.     int                             m_iXmove;                                       // 移动时X坐标平移  
  224.     int                             m_iYmove;                                       // 移动时Y坐标平移  
  225.     int                             m_liMaxLXmove;                                  // 最大左移       
  226.     int                             m_liMaxRXmove;                                  // 最大右移  
  227.     int                             m_liMaxUYmove;                                  // 最大上移  
  228.     int                             m_liMaxDYmove;                                  // 最大下移   
  229.     BOOL                            m_bIsInMove;                                    // 是否在移动  
  230.   
  231.     int                             m_iXChange;                                     // 改变时X坐标平移  
  232.     int                             m_iYChange;                                     // 改变时Y坐标平移  
  233.     e_CheckBordType                 m_eCheckBordType;                               // 鼠标选中区域类型  
  234.     BOOL                            m_bIsHitBorder;                                 // 是否停留在边框  
  235.     BOOL                            m_bInChangeSize;                                // 改变大小中  
  236.     TCHAR*                          m_pMouseIcon;                                   // 鼠标图标  
  237.     BOOL                            m_bIsMaxSize;                                   // 是否最大化  
  238.       
  239.   
  240.     BOOL                            m_bPrntBkColor;  
  241.     BOOL                            m_bPrntBkImage;  
  242.     BOOL                            m_bPrntGdiPlusImage;  
  243.     BOOL                            m_bPrntText;  
  244.     BOOL                            m_bPrntBorder;  
  245.     CStdString                      m_strWinText;                                    // 文字  
  246.     CStdString                      m_strTextName;                                   // 文字名称  
  247.     ULong                           m_ulTextColor;                                   // 颜色  
  248.     ULong                           m_ulDisTextColor;  
  249.     ULong                           m_ulTextStyle;                                   // 风格  
  250.     BOOL                            m_bIsVisiable;                                   // 是否可见(可用)  
  251. private:  
  252.     RECT                            m_oRectBefore;  
  253.     int                             m_iStytle;  
  254.     int                             m_iFont;                                         // 字体  
  255. };  
  256.   
  257.   
  258. #endif//H_CUIBASECTRL_H  


实现如下：

[cpp] view plain copy print ?
  1. #include "StdAfx.h"  
  2. #include "UIBaseCtrl.h"  
  3. #include "UIWinWnd.h"  
  4.   
  5. CUIBaseCtrl::CUIBaseCtrl(CUICache* apCache, CWinWnd* apWinWnd)   
  6. : m_bColorHSL(FALSE)  
  7. , m_bTestMouseHit(TRUE)  
  8. , m_bTestMouseLeave(TRUE)  
  9. , m_bIsInMove(FALSE)  
  10. , m_bIsHitBorder(FALSE)  
  11. , m_bInChangeSize(0)  
  12. , m_bIsMaxSize(FALSE)  
  13. , m_bIsFocus(FALSE)  
  14. , m_bPrntBkColor(TRUE)  
  15. , m_bPrntBkImage(TRUE)  
  16. , m_bPrntGdiPlusImage(FALSE)  
  17. , m_bPrntText(TRUE)  
  18. , m_bPrntBorder(FALSE)  
  19. , m_pBkImage(NULL)  
  20. , m_pUIResCache(apCache)  
  21. , m_ulNomalBordecCl(0x999999)   
  22. , m_ulFocusBordecCl(0x388E8E) // 选中后的颜色  
  23. , m_iBorderSize(1)  
  24. , m_pParentCtrl(0)  
  25. , m_pMouseIcon(0)  
  26. , m_iXmove(0)  
  27. , m_iYmove(0)  
  28. , m_iStytle(SW_RESTORE)  
  29. , m_iRound(0)  
  30. , m_iFont(-1)  
  31. , m_liMaxLXmove(0)  
  32. , m_liMaxRXmove(0)  
  33. , m_liMaxUYmove(0)  
  34. , m_liMaxDYmove(0)    
  35. , m_ulTextColor(0x555555)  
  36. , m_bIsVisiable(TRUE)  
  37. , m_strTextName(_T("Default"))  
  38. {  
  39.     memset(&m_oRectPrint, 0, sizeof(RECT));  
  40.     m_cxyBorderRound.cx = 0;  
  41.     m_cxyBorderRound.cy = 0;  
  42.     m_hWinWnd = apWinWnd;  
  43.     m_hWnd = m_hWinWnd->GetWnd();  
  44. }  
  45.   
  46. CUIBaseCtrl::~CUIBaseCtrl(void)  
  47. {  
  48. }  
  49.   
  50. // 设置控件ID  
  51. void    CUIBaseCtrl::SetCtrlID(ULong aulCtrlID)  
  52. {  
  53.     m_ulCtrlID = aulCtrlID;  
  54. }  
  55.   
  56. // 设置是否可见  
  57. void    CUIBaseCtrl::SetVisiable(BOOL abIsVisiable)  
  58. {  
  59.     m_bIsVisiable =  abIsVisiable;  
  60.     ::InvalidateRect(m_hWnd, &GetRect(), TRUE);  
  61. }   
  62.   
  63. // 获取是否可见  
  64. BOOL    CUIBaseCtrl::GetVisiable(void)  
  65. {  
  66.     return m_bIsVisiable;  
  67. }                     
  68.   
  69. // 获取控件ID  
  70. ULong   CUIBaseCtrl::GetCtrlID(void)  
  71. {  
  72.     return m_ulCtrlID;  
  73. }  
  74.   
  75.  HWND CUIBaseCtrl::GetWnd(void)   
  76.  {  
  77.     return m_hWinWnd->GetWnd();  
  78.  }  
  79.   
  80.  HINSTANCE CUIBaseCtrl::GetInstance(void)  
  81.  {  
  82.     return m_hWinWnd->GetInstance();  
  83.  }  
  84.   
  85. void CUIBaseCtrl::SetRect(int aiXVertex, int aiYVertex, int aiWidth, int aiHeight)  
  86. {  
  87.     if (aiWidth < m_iBorderSize*3)     
  88.         aiWidth =  m_iBorderSize*3;  
  89.   
  90.     if (aiHeight < m_iBorderSize*3)    
  91.         aiHeight = m_iBorderSize*3;  
  92.   
  93.     m_oRect.left   = aiXVertex;  
  94.     m_oRect.right  = aiXVertex + aiWidth;  
  95.     m_oRect.top    = aiYVertex;  
  96.     m_oRect.bottom = aiYVertex + aiHeight;  
  97.     m_oWockRect    = m_oRect;  
  98.     if (m_iBorderSize) SetBordeRect();  
  99. }  
  100.   
  101. // 设置控件所在矩形区域  
  102. void CUIBaseCtrl::SetRect(RECT& aoRect)  
  103. {  
  104.     if ((aoRect.right - aoRect.left) < (m_iBorderSize*3))  
  105.         aoRect.right = aoRect.left + (m_iBorderSize*3);  
  106.   
  107.     if ((aoRect.bottom - aoRect.top) < (m_iBorderSize*3))  
  108.         aoRect.bottom = aoRect.top + (m_iBorderSize*3);  
  109.     m_oRect     = aoRect;  
  110.     m_oWockRect = aoRect;  
  111.     if (m_iBorderSize)   
  112.         SetBordeRect();  
  113.     ::InvalidateRect(m_hWnd,&m_oRect,TRUE);  
  114. }  
  115.   
  116.   
  117. void CUIBaseCtrl::SetBordeRect(void)  
  118. {  
  119.   
  120.     // 矫正工作区域  
  121.     m_oWockRect.left        += m_iBorderSize;  
  122.     m_oWockRect.right       -= m_iBorderSize;  
  123.     m_oWockRect.top         += m_iBorderSize;  
  124.     m_oWockRect.bottom      -= m_iBorderSize;  
  125.   
  126.     // 计算左边界矩形  
  127.     m_oBordeLRect.left      =  m_oRect.left;  
  128.     m_oBordeLRect.right     =  m_oBordeLRect.left       + m_iBorderSize;  
  129.     m_oBordeLRect.top       =  m_oRect.top              + m_iBorderSize ;  
  130.     m_oBordeLRect.bottom    =  m_oRect.bottom           - m_iBorderSize ;  
  131.   
  132.     // 计算右边界矩形  
  133.     m_oBordeRRect.left      =  m_oRect.right            - m_iBorderSize;  
  134.     m_oBordeRRect.right     =  m_oRect.right;  
  135.     m_oBordeRRect.top       =  m_oRect.top              + m_iBorderSize ;  
  136.     m_oBordeRRect.bottom    =  m_oRect.bottom           - m_iBorderSize ;  
  137.   
  138.     // 计算上边界矩形  
  139.     m_oBordeTRect.left      =  m_oRect.left             + m_iBorderSize ;  
  140.     m_oBordeTRect.right     =  m_oRect.right            - m_iBorderSize ;  
  141.     m_oBordeTRect.top       =  m_oRect.top;  
  142.     m_oBordeTRect.bottom    =  m_oRect.top              + m_iBorderSize;  
  143.   
  144.     // 计算下边界矩形  
  145.     m_oBordeBRect.left      =  m_oRect.left             + m_iBorderSize;  
  146.     m_oBordeBRect.right     =  m_oRect.right            - m_iBorderSize;  
  147.     m_oBordeBRect.top       =  m_oRect.bottom           - m_iBorderSize;  
  148.     m_oBordeBRect.bottom    =  m_oRect.bottom;  
  149.   
  150.     // 计算左顶点  
  151.     m_oBordeLTRect.left     =  m_oRect.left;  
  152.     m_oBordeLTRect.right    =  m_oRect.left             + m_iBorderSize*4;  
  153.     m_oBordeLTRect.top      =  m_oRect.top;  
  154.     m_oBordeLTRect.bottom   =  m_oRect.top              + m_iBorderSize*4;  
  155.   
  156.     // 计算右顶点  
  157.     m_oBordeRTRect.left     =  m_oRect.right            - m_iBorderSize*4;  
  158.     m_oBordeRTRect.right    =  m_oRect.right;  
  159.     m_oBordeRTRect.top      =  m_oRect.top;  
  160.     m_oBordeRTRect.bottom   =  m_oRect.top              + m_iBorderSize*4;  
  161.   
  162.     // 计算左底点  
  163.     m_oBordeLBRect.left     =  m_oRect.left;  
  164.     m_oBordeLBRect.right    =  m_oRect.left             + m_iBorderSize*4;  
  165.     m_oBordeLBRect.top      =  m_oRect.bottom           - m_iBorderSize*4;  
  166.     m_oBordeLBRect.bottom   =  m_oRect.bottom;  
  167.   
  168.     // 计算右底点  
  169.     m_oBordeRBRect.left     =  m_oRect.right            - m_iBorderSize*4;  
  170.     m_oBordeRBRect.right    =  m_oRect.right;  
  171.     m_oBordeRBRect.top      =  m_oRect.bottom           - m_iBorderSize*4;  
  172.     m_oBordeRBRect.bottom   =  m_oRect.bottom;  
  173. }  
  174.   
  175. // 获取控件所在矩形区域  
  176. RECT& CUIBaseCtrl::GetRect(void)  
  177. {  
  178.     return m_oRect;  
  179. }     
  180.   
  181. // 获取工作区域矩形  
  182. RECT& CUIBaseCtrl::GetWorkRect(void)  
  183. {  
  184.     return m_oWockRect;  
  185. }                                                     
  186.   
  187. // 获取控件宽度  
  188. int CUIBaseCtrl::GetWidth(void)  
  189. {  
  190.      return (m_oRect.right - m_oRect.left);  
  191. }  
  192.   
  193. // 获取控件高度  
  194. int CUIBaseCtrl::GetHeight(void)  
  195. {  
  196.     return (m_oRect.bottom - m_oRect.top);  
  197. }                                                         
  198. // 获取顶点X  
  199. int CUIBaseCtrl::GetXVertex(void)  
  200. {  
  201.     return  m_oRect.left;  
  202. }  
  203. // 获取顶点Y  
  204. int CUIBaseCtrl::GetYVertex(void)  
  205. {  
  206.     return  m_oRect.top;  
  207. }                                                         
  208.   
  209. // 设置控件边框  
  210. void CUIBaseCtrl::SetBorderSize(int aiBorderSize)  
  211. {  
  212.     m_iBorderSize = aiBorderSize;  
  213.     Invalidate();  
  214. }     
  215.   
  216. // 获取控件边框  
  217. int  CUIBaseCtrl::GetBorderSize(void)  
  218. {  
  219.     return m_iBorderSize;  
  220. }  
  221.   
  222. // 设置控件圆角  
  223. void CUIBaseCtrl::SetBorderRound(SIZE asBorderRound)  
  224. {  
  225.     m_cxyBorderRound.cx = asBorderRound.cx;  
  226.     m_cxyBorderRound.cy = asBorderRound.cy;  
  227.     Invalidate();  
  228. }  
  229.   
  230. // 获取控件圆角  
  231. SIZE CUIBaseCtrl::GetBorderRound(void)  
  232. {  
  233.     return m_cxyBorderRound;  
  234. }         
  235. // 设置窗体圆角  
  236. void CUIBaseCtrl::SetWndRound(int aiRound)  
  237. {  
  238.     m_iRound = aiRound;  
  239.     SIZE liSize;  
  240.     liSize.cx = m_iRound;  
  241.     liSize.cy = m_iRound;  
  242.     SetBorderRound(liSize);  
  243.   
  244. }  
  245. // 获取窗体圆角  
  246. int CUIBaseCtrl::GetWndRound(void)  
  247. {  
  248.     return m_iRound;  
  249. }  
  250.   
  251.   
  252. // 增加子控件  
  253. BOOL CUIBaseCtrl::AddChildCtrl(CUIBaseCtrl* apCtrl)  
  254. {  
  255.     if (!apCtrl)  
  256.         return FALSE;  
  257.     m_pChildCtrlSet.Insert(apCtrl);  
  258.     apCtrl->SetParentCtrl(this);  
  259.   
  260.     return TRUE;  
  261. }     
  262. // 设置父控件  
  263. BOOL CUIBaseCtrl::SetParentCtrl(CUIBaseCtrl* apParentCtrl)  
  264. {  
  265.     if (! apParentCtrl)  
  266.         return FALSE;  
  267.     m_pParentCtrl = apParentCtrl;  
  268.     return TRUE;  
  269. }         
  270. // 获取父控件  
  271. CUIBaseCtrl*    CUIBaseCtrl::GetParentCtrl(void)  
  272. {  
  273.     return m_pParentCtrl;  
  274. }  
  275.   
  276. // 设置控件数据  
  277. void CUIBaseCtrl::SetData(unsigned char* apData)  
  278. {  
  279.     m_pData = apData;  
  280. }     
  281.   
  282. // 获取控件数据  
  283. UInt8* CUIBaseCtrl::GetData(void) const  
  284. {  
  285.     return m_pData;  
  286. }  
  287.   
  288. // 设置窗口是否最大化  
  289. void CUIBaseCtrl::SetMaxSize(BOOL abIsMaxSize)  
  290. {  
  291.     m_bIsMaxSize = abIsMaxSize;  
  292.     if (m_pParentCtrl)  
  293.         m_pParentCtrl->SetMaxSize(abIsMaxSize);  
  294. }  
  295.   
  296. // 获取窗口是否最大化  
  297. BOOL CUIBaseCtrl::GetMaxSize(void)  
  298. {  
  299.     return m_bIsMaxSize;  
  300. }                                                 
  301.   
  302. void CUIBaseCtrl::SetBkColor(ULong aulBkColor)  
  303. {  
  304.     m_ulBkColor = aulBkColor;  
  305. }  
  306.   
  307. ULong CUIBaseCtrl::GetBkColor(void)  
  308. {  
  309.     return m_ulBkColor;  
  310. }  
  311.   
  312. // 设置背图片  
  313. void   CUIBaseCtrl::SetBkImage(TCHAR* apImageName)  
  314. {  
  315.     if (NULL == apImageName)  
  316.         return;  
  317.       
  318.     if (m_pBkImage)  
  319.          delete [] m_pBkImage;  
  320.   
  321.     int liCnt = 0;  
  322. #ifdef UNICODE  
  323.     liCnt = wcslen(apImageName);  
  324. #else  
  325.     liCnt = strlen(apImageName);  
  326. #endif  
  327.   
  328.     m_pBkImage = new TCHAR[liCnt+1];  
  329.     memset(m_pBkImage, 0 , sizeof(TCHAR)* (liCnt+1));  
  330.     memcpy(m_pBkImage, apImageName,sizeof(TCHAR)* liCnt);  
  331. }     
  332.   
  333. // 获取背图片  
  334. TCHAR* CUIBaseCtrl::GetBkImage(void)  
  335. {  
  336.     return m_pBkImage;  
  337. }         
  338.   
  339.   
  340. // 设置状态图片  
  341. void   CUIBaseCtrl::SetStatusImage(TCHAR* apImageName)  
  342. {  
  343.     if (apImageName)  
  344.         m_oStatusImage = apImageName;  
  345. }  
  346.   
  347. // 获取状态图片  
  348. CStdString& CUIBaseCtrl::GetStatusImage(void)  
  349. {  
  350.     return m_oStatusImage;  
  351. }  
  352.   
  353. // 删除子控件  
  354. BOOL CUIBaseCtrl::DelChildCtrl(CUIBaseCtrl* apCtrl)  
  355. {  
  356.     if (!apCtrl)  
  357.         return FALSE;  
  358.     m_pChildCtrlSet.Erase(apCtrl);  
  359.     return TRUE;  
  360. }     
  361.   
  362. void CUIBaseCtrl::OnPaint(HDC ahDC, const RECT& aoRect, S_MsgEventUI& apEvent)  
  363. {  
  364.     //如果没有重叠区域  
  365.     if( !::IntersectRect(&m_oRectPrint, &aoRect, &m_oRect))   
  366.         return;  
  367.     // 分派给控件  
  368.     OnCtrlMsg(apEvent);  
  369.   
  370.     // 如果可见的话再绘制  
  371.     if (m_bIsVisiable)  
  372.     {  
  373.         // 绘制背景  
  374.         if (m_bPrntBkColor)  
  375.             PaintBkColor(ahDC);  
  376.         // 背景贴图  
  377.         if(m_bPrntBkImage)    
  378.             PaintBkImage(ahDC);  
  379.         // 状态贴图  
  380.         if(m_bPrntGdiPlusImage)  
  381.             PaintGdiplusImage(ahDC);  
  382.         // 文字  
  383.         if(m_bPrntText)  
  384.             PaintText(ahDC);  
  385.         // 边框  
  386.         if(m_bPrntBorder)  
  387.             PaintBorder(ahDC);  
  388.     }  
  389.   
  390.     CUIBaseCtrl* lpChildCtrl = NULL;  
  391.     for (int i = m_pChildCtrlSet.Size() -1; i>=0 ; i--)  
  392.     {  
  393.         lpChildCtrl = m_pChildCtrlSet[i];  
  394.         if (lpChildCtrl)  
  395.         {  
  396.             apEvent.m_ulCtrlId = lpChildCtrl->GetCtrlID();  
  397.             apEvent.m_pCtrl    = lpChildCtrl;  
  398.             lpChildCtrl->OnPaint(ahDC, aoRect, apEvent);  
  399.         }  
  400.     }  
  401.     SetFocus(FALSE);  
  402. }  
  403.   
  404. // 大小改变时  
  405. void CUIBaseCtrl::OnSize(S_MsgEventUI& apEvent)  
  406. {  
  407.     CUIBaseCtrl* lpChildCtrl = NULL;  
  408.     for (int i = m_pChildCtrlSet.Size() -1; i>=0 ; i--)  
  409.     {  
  410.         lpChildCtrl = m_pChildCtrlSet[i];  
  411.         if (lpChildCtrl)  
  412.         {  
  413.             apEvent.m_ulCtrlId = lpChildCtrl->GetCtrlID();  
  414.             apEvent.m_pCtrl    = lpChildCtrl;  
  415.             lpChildCtrl->OnSize(apEvent);  
  416.         }  
  417.     }  
  418. }                                     
  419.   
  420. // 控件广播消息  
  421. void CUIBaseCtrl::OnCtrlBroadcast(S_MsgEventUI& apEvent)  
  422. {  
  423.     CUIBaseCtrl* lpChildCtrl = NULL;  
  424.     apEvent.m_ulCtrlId  = m_ulCtrlID;  
  425.     apEvent.m_pCtrl     = this;  
  426.     OnCtrlMsg(apEvent);  
  427.     for (int i = m_pChildCtrlSet.Size() -1; i>=0 ; i--)  
  428.     {  
  429.         lpChildCtrl = m_pChildCtrlSet[i];  
  430.         if (lpChildCtrl)  
  431.             lpChildCtrl->OnCtrlBroadcast(apEvent);  
  432.     }  
  433. }  
  434.   
  435. // 绘制背景  
  436. void CUIBaseCtrl::PaintBkColor(HDC ahDC)  
  437. {  
  438.     if (m_ulBkColor != 0)  
  439.         CRenderEngine::DrawColor(ahDC, m_oRect, m_ulBkColor);  
  440. }     
  441.   
  442. void CUIBaseCtrl::PaintBkImage(HDC hDC)  
  443. {  
  444.     if (m_pBkImage)  
  445.         DrawImage(hDC, m_pBkImage);  
  446. }  
  447.   
  448. // 是否选中  
  449. void    CUIBaseCtrl::SetFocus(BOOL abIsFocus)  
  450. {  
  451.     m_bIsFocus = abIsFocus;  
  452. }     
  453.   
  454. // 绘制图片  
  455. BOOL CUIBaseCtrl::DrawImage(HDC hDC, TCHAR* apImageName, LPCTSTR pStrModify/* = NULL*/, int aiNarrow/* = 0*/)  
  456. {  
  457.     if (aiNarrow)  
  458.     {  
  459.         RECT loRect = m_oRect;  
  460.         loRect.left   += aiNarrow;  
  461.         loRect.right  -= aiNarrow;  
  462.         loRect.bottom -= aiNarrow;  
  463.         loRect.top    += aiNarrow;  
  464.         return CRenderEngine::DrawImageString(m_pUIResCache, hDC, loRect, m_oRectPrint,  apImageName,  pStrModify );  
  465.     }  
  466.     else  
  467.         return CRenderEngine::DrawImageString(m_pUIResCache, hDC, m_oRect, m_oRectPrint,  apImageName,  pStrModify);  
  468. }  
  469.   
  470. // 更新  
  471. void    CUIBaseCtrl::Invalidate(void)  
  472. {    
  473.     ::InvalidateRect(m_hWnd,&m_oRect, TRUE);   
  474. }             
  475.                                       
  476. // 绘制状态图  
  477. void CUIBaseCtrl::PaintGdiplusImage(HDC hDC)  
  478. {  
  479.     if (m_bPrntGdiPlusImage)  
  480.         CRenderEngine::DrawImageGdiPlus(m_pUIResCache, hDC, m_oStatusImage,  Gdiplus::RectF(m_oRect.left, m_oRect.top, (m_oRect.right - m_oRect.left), (m_oRect.bottom - m_oRect.top)));  
  481. }  
  482.   
  483. // 绘制文字  
  484. void CUIBaseCtrl::PaintText(HDC hDC)  
  485. {  
  486.   
  487. }  
  488.   
  489. // 绘制边框  
  490. void CUIBaseCtrl::PaintBorder(HDC hDC)  
  491. {  
  492.     if( m_iBorderSize > 0 )  
  493.     {  
  494.         if( m_cxyBorderRound.cx > 0 || m_cxyBorderRound.cy > 0 )  
  495.         {  
  496.             if (m_bIsFocus && m_ulFocusBordecCl != 0)  
  497.                 CRenderEngine::DrawRoundRect(hDC, m_oRect, m_iBorderSize, m_cxyBorderRound.cx, m_cxyBorderRound.cy, m_ulFocusBordecCl);  
  498.             else  
  499.                 CRenderEngine::DrawRoundRect(hDC, m_oRect, m_iBorderSize, m_cxyBorderRound.cx, m_cxyBorderRound.cy, m_ulNomalBordecCl);  
  500.         }  
  501.         else  
  502.         {  
  503.             if (m_bIsFocus && m_ulFocusBordecCl != 0)  
  504.                 CRenderEngine::DrawRect(hDC, m_oRect, m_iBorderSize, m_ulFocusBordecCl);  
  505.             else if (m_ulNomalBordecCl != 0)  
  506.                 CRenderEngine::DrawRect(hDC, m_oRect, m_iBorderSize,m_ulNomalBordecCl);   
  507.         }  
  508.     }  
  509. }  
  510.   
  511. void CUIBaseCtrl::PaintMoveBorder(HDC hDC)  
  512. {  
  513.     if (m_bIsInMove)  
  514.     {  
  515.         if( m_cxyBorderRound.cx > 0 || m_cxyBorderRound.cy > 0 )  
  516.         {  
  517.             if (m_bIsFocus && m_ulFocusBordecCl != 0)  
  518.                 CRenderEngine::DrawRoundRect(hDC, m_oMovingRect, m_iBorderSize, m_cxyBorderRound.cx, m_cxyBorderRound.cy, m_ulFocusBordecCl);  
  519.             else  
  520.                 CRenderEngine::DrawRoundRect(hDC, m_oMovingRect, m_iBorderSize, m_cxyBorderRound.cx, m_cxyBorderRound.cy, m_ulNomalBordecCl);  
  521.         }  
  522.         else  
  523.         {  
  524.             if (m_bIsFocus && m_ulFocusBordecCl != 0)  
  525.                 CRenderEngine::DrawRect(hDC, m_oMovingRect, m_iBorderSize, m_ulFocusBordecCl);  
  526.             else if (m_ulNomalBordecCl != 0)  
  527.                 CRenderEngine::DrawRect(hDC, m_oMovingRect, m_iBorderSize,m_ulNomalBordecCl);  
  528.         }  
  529.     }  
  530. }  
  531.   
  532. void CUIBaseCtrl::PaintChangeSize(HDC hDC)  
  533. {  
  534.     if (m_bInChangeSize)  
  535.     {  
  536.         if( m_cxyBorderRound.cx > 0 || m_cxyBorderRound.cy > 0 )  
  537.         {  
  538.             if (m_bIsFocus && m_ulFocusBordecCl != 0)  
  539.                 CRenderEngine::DrawRoundRect(hDC, m_oMovingRect, m_iBorderSize, m_cxyBorderRound.cx, m_cxyBorderRound.cy, m_ulFocusBordecCl);  
  540.             else  
  541.                 CRenderEngine::DrawRoundRect(hDC, m_oMovingRect, m_iBorderSize, m_cxyBorderRound.cx, m_cxyBorderRound.cy, m_ulNomalBordecCl);  
  542.         }  
  543.         else  
  544.         {  
  545.             if (m_bIsFocus && m_ulFocusBordecCl != 0)  
  546.                 CRenderEngine::DrawRect(hDC, m_oMovingRect, m_iBorderSize, m_ulFocusBordecCl);  
  547.             else if (m_ulNomalBordecCl != 0)  
  548.                 CRenderEngine::DrawRect(hDC, m_oMovingRect, m_iBorderSize, m_ulNomalBordecCl);  
  549.         }  
  550.     }  
  551. }  
  552.   
  553.   
  554.   
  555. // 坐标是否在控件区域内  
  556. BOOL CUIBaseCtrl::IsPtInCtrlRect(POINT& aoPoint)  
  557. {  
  558.     return CRenderEngine::IsPtInRect(aoPoint, m_oRect);  
  559. }     
  560.   
  561. // 坐标是否在工作区域内  
  562. BOOL CUIBaseCtrl::IsPtInWorkRect(POINT& aoPoint)                                                      
  563. {  
  564.     return CRenderEngine::IsPtInRect(aoPoint, m_oWockRect);  
  565. }     
  566.   
  567. // 坐标是否左边框内  
  568. BOOL CUIBaseCtrl::IsPtInLRect(POINT& aoPoint)                                                     
  569. {  
  570.     return CRenderEngine::IsPtInRect(aoPoint, m_oBordeLRect);  
  571. }         
  572.   
  573. // 坐标是否右边框内  
  574. BOOL CUIBaseCtrl::IsPtInRRect(POINT& aoPoint)                                                     
  575. {  
  576.     return CRenderEngine::IsPtInRect(aoPoint, m_oBordeRRect);  
  577. }  
  578.   
  579. // 坐标是否上边框内  
  580. BOOL CUIBaseCtrl::IsPtInTRect(POINT& aoPoint)                                                     
  581. {  
  582.     return CRenderEngine::IsPtInRect(aoPoint, m_oBordeTRect);  
  583. }  
  584.   
  585. // 坐标是否下边框内  
  586. BOOL CUIBaseCtrl::IsPtInBRect(POINT& aoPoint)                                                     
  587. {  
  588.     return CRenderEngine::IsPtInRect(aoPoint, m_oBordeBRect);  
  589. }  
  590.   
  591. // 坐标是否左顶点  
  592. BOOL CUIBaseCtrl::IsPtInLTRect(POINT& aoPoint)                                                    
  593. {  
  594.     return CRenderEngine::IsPtInRect(aoPoint, m_oBordeLTRect);  
  595. }  
  596.   
  597. // 坐标是否右顶点  
  598. BOOL CUIBaseCtrl::IsPtInRTRect(POINT& aoPoint)                                                    
  599. {  
  600.     return CRenderEngine::IsPtInRect(aoPoint, m_oBordeRTRect);  
  601. }  
  602.   
  603. // 坐标是否上底点  
  604. BOOL CUIBaseCtrl::IsPtInLBRect(POINT& aoPoint)                                                    
  605. {  
  606.     return CRenderEngine::IsPtInRect(aoPoint, m_oBordeLBRect);  
  607. }  
  608.   
  609. // 坐标是否下底点  
  610. BOOL CUIBaseCtrl::IsPtInRBRect(POINT& aoPoint)                                                    
  611. {  
  612.     return CRenderEngine::IsPtInRect(aoPoint, m_oBordeRBRect);  
  613. }  
  614.   
  615. // 找到指定坐标所属的子窗口  
  616. CUIBaseCtrl* CUIBaseCtrl::FindCtrl(POINT& aoPoint)  
  617. {  
  618.     CUIBaseCtrl* lpFindCtrl = NULL;  
  619.     // 如果在当前区域内  
  620.     if (IsPtInCtrlRect(aoPoint))  
  621.     {  
  622.         for (int i = m_pChildCtrlSet.Size() -1; i>=0 ; i--)  
  623.         {  
  624.             lpFindCtrl = m_pChildCtrlSet[i];  
  625.             if (lpFindCtrl)  
  626.                 if (NULL !=  lpFindCtrl->FindCtrl(aoPoint))   
  627.                     return lpFindCtrl->FindCtrl(aoPoint);  
  628.         }  
  629.         return this;  
  630.     }  
  631.     return NULL;  
  632. }  
  633. // 获得底层控件  
  634. CUIBaseCtrl* CUIBaseCtrl::GetTopCtrl(void)  
  635. {  
  636.     if (NULL != m_pParentCtrl)  
  637.         return m_pParentCtrl->GetTopCtrl();  
  638.     return this;  
  639. }  
  640.                                   
  641.   
  642. // 控件消息分派  
  643. void CUIBaseCtrl::OnCtrlMsg(S_MsgEventUI& apEvent)  
  644. {  
  645.     if (m_pUIResCache)  
  646.     {  
  647.         MsgCallBack lpfCBack = m_pUIResCache->GetMsgBack(apEvent.m_ulMsgId, apEvent.m_ulCtrlId);  
  648.         if ((lpfCBack)&&(m_hWinWnd))  
  649.             (m_hWinWnd->*lpfCBack)(apEvent);  
  650.     }  
  651. }                             
  652.   
  653. // 当鼠标左键落下  
  654. void CUIBaseCtrl::OnLButtonDown(S_MsgEventUI& apEvent)  
  655. {  
  656.     OnCtrlMsg(apEvent);  
  657. }  
  658.   
  659. // 当鼠标左键弹起时                       
  660. void CUIBaseCtrl::OnLButtonUP(S_MsgEventUI& apEvent)  
  661. {  
  662.     OnCtrlMsg(apEvent);  
  663. }         
  664.   
  665. // 当鼠标左键双击  
  666. void CUIBaseCtrl::OnLBuDbClk(S_MsgEventUI& apEvent)  
  667. {  
  668.     OnCtrlMsg(apEvent);  
  669. }  
  670.   
  671. // 当鼠标右键落下  
  672. void CUIBaseCtrl::OnRButtonDown(S_MsgEventUI& apEvent)  
  673. {  
  674.     OnCtrlMsg(apEvent);  
  675. }  
  676.   
  677. // 当鼠标右键弹起时  
  678. void CUIBaseCtrl::OnRButtonUP(S_MsgEventUI& apEvent)  
  679. {  
  680.     OnCtrlMsg(apEvent);  
  681. }  
  682.   
  683. // 当鼠标右键双击  
  684. void CUIBaseCtrl::OnRBuDbClk(S_MsgEventUI& apEvent)  
  685. {  
  686.     OnCtrlMsg(apEvent);  
  687. }                                     
  688.   
  689. void CUIBaseCtrl::OnMouseHover(S_MsgEventUI& apEvent)  
  690. {  
  691.     OnCtrlMsg(apEvent);  
  692. }  
  693. void CUIBaseCtrl::OnMouseMove(S_MsgEventUI& apEvent)  
  694. {  
  695.     OnCtrlMsg(apEvent);  
  696. }  
  697.   
  698.   
  699. void CUIBaseCtrl::OnMouseHit(S_MsgEventUI& apEvent)  
  700. {  
  701.     OnCtrlMsg(apEvent);  
  702. }  
  703.   
  704. // 鼠标移动到  
  705. void CUIBaseCtrl::OnMouseLeave(S_MsgEventUI& apEvent)  
  706. {  
  707.     OnCtrlMsg(apEvent);  
  708. }  
  709.   
  710. // 失去焦点  
  711. void CUIBaseCtrl::OnKillFocus(S_MsgEventUI& apEvent)  
  712. {  
  713.     OnCtrlMsg(apEvent);  
  714. }  
  715.   
  716. // 开始移动  
  717. void CUIBaseCtrl::BegMoveWindow(POINT& aoPtMouse)  
  718. {  
  719.     // 优先改变  
  720.     if (IsPtInWorkRect(aoPtMouse))  
  721.     {  
  722.         m_iXmove = aoPtMouse.x;  
  723.         m_iYmove = aoPtMouse.y;  
  724.         m_bIsInMove = TRUE;  
  725.     }  
  726. }  
  727.   
  728. // 窗口移动  
  729. void CUIBaseCtrl::MoveChildWindow(int aiXMove, int aiYMove)  
  730. {  
  731.     CUIBaseCtrl* lpChildCtrl = NULL;  
  732.     CRect loCholdRect;  
  733.   
  734.     for (int i = m_pChildCtrlSet.Size() -1; i>=0 ; i--)  
  735.     {  
  736.         lpChildCtrl = m_pChildCtrlSet[i];  
  737.         if (lpChildCtrl)  
  738.         {  
  739.             loCholdRect = lpChildCtrl->GetRect();  
  740.             loCholdRect.left  += aiXMove;  
  741.             loCholdRect.right += aiXMove;  
  742.             loCholdRect.top   += aiYMove;  
  743.             loCholdRect.bottom+= aiYMove;  
  744.             lpChildCtrl->SetRect(loCholdRect);  
  745.             lpChildCtrl->MoveChildWindow(aiXMove, aiYMove);  
  746.         }  
  747.     }  
  748. }  
  749.   
  750. // 结束移动  
  751. void CUIBaseCtrl::EndMoveWindow(POINT& aoPtMouse)  
  752. {  
  753.     DrawMoveRect(aoPtMouse);  
  754.     if((((0 == m_iXmove) && (0 == m_iYmove)) ||   
  755.         ((0 == aoPtMouse.x) && (0 == aoPtMouse.y))))  
  756.     { return;}  
  757.     RECT loRectUpdate = m_oRect;  
  758.     // 平移  
  759.     m_iXmove                =   aoPtMouse.x - m_iXmove;  
  760.     m_iYmove                =   aoPtMouse.y - m_iYmove;  
  761.     RECT loCtrlRect         =   m_oRect;  
  762.     loCtrlRect.left         +=  m_iXmove;  
  763.     loCtrlRect.right        +=  m_iXmove;  
  764.     loCtrlRect.top          +=  m_iYmove;  
  765.     loCtrlRect.bottom       +=  m_iYmove;  
  766.     m_iXmove = 0;  
  767.     m_iYmove = 0;  
  768.     // 矫正  
  769.     RECT loRectParent;  
  770.   
  771.     if (!m_pParentCtrl)   
  772.         ::GetClientRect(m_hWnd, &loRectParent);  
  773.   
  774.     else loRectParent = m_pParentCtrl->GetRect();  
  775.     if (loCtrlRect.left < loRectParent.left)     m_iXmove = loRectParent.left    - loCtrlRect.left;  
  776.     if (loCtrlRect.right > loRectParent.right)       m_iXmove = loRectParent.right   - loCtrlRect.right;  
  777.     if (loCtrlRect.top < loRectParent.top)           m_iYmove = loRectParent.top     - loCtrlRect.top;  
  778.     if (loCtrlRect.bottom > loRectParent.bottom) m_iYmove = loRectParent.bottom  - loCtrlRect.bottom;  
  779.     // 平移  
  780.     loCtrlRect.left     += m_iXmove;  
  781.     loCtrlRect.right    += m_iXmove;  
  782.     loCtrlRect.top      += m_iYmove;  
  783.     loCtrlRect.bottom   += m_iYmove;  
  784.   
  785.     // 移动子窗口  
  786.     int liXChildMove = loCtrlRect.left  - m_oRect.left;  
  787.     int liYChildMove = loCtrlRect.top - m_oRect.top;  
  788.     MoveChildWindow(liXChildMove, liYChildMove);  
  789.     // 重置控件矩形  
  790.     SetRect(loCtrlRect);  
  791.       
  792.     loRectUpdate.left     = min(loRectUpdate.left, loCtrlRect.left);  
  793.     loRectUpdate.right    = max(loRectUpdate.right, loCtrlRect.right);  
  794.     loRectUpdate.top      = min(loRectUpdate.top, loCtrlRect.top    );  
  795.     loRectUpdate.bottom   = max(loRectUpdate.bottom,loCtrlRect.bottom);  
  796.   
  797.     // 更新  
  798.     ::InvalidateRect(m_hWnd, &loRectUpdate,TRUE);  
  799.     m_bIsInMove = FALSE;  
  800.     m_liMaxLXmove = 0;  
  801.     m_liMaxRXmove = 0;  
  802.     m_liMaxUYmove = 0;  
  803.     m_liMaxDYmove = 0;    
  804. }     
  805.   
  806. // 绘制移动时区域  
  807. void CUIBaseCtrl::DrawMoveRect(POINT& aoPtMouse)  
  808. {  
  809.     if((0 == m_iXmove) && (0 == m_iYmove) && (!m_bIsInMove))  
  810.     { return;}  
  811.   
  812.     if (m_liMaxLXmove > (aoPtMouse.x - m_iXmove)) m_liMaxLXmove = (aoPtMouse.x - m_iXmove);  
  813.     if (m_liMaxRXmove < (aoPtMouse.x - m_iXmove)) m_liMaxRXmove = (aoPtMouse.x - m_iXmove);  
  814.     if (m_liMaxUYmove > (aoPtMouse.y - m_iYmove)) m_liMaxUYmove = (aoPtMouse.y - m_iYmove);  
  815.     if (m_liMaxDYmove < (aoPtMouse.y - m_iYmove)) m_liMaxDYmove = (aoPtMouse.y - m_iYmove);  
  816.   
  817.     // 平移  
  818.     int  liXmove         = aoPtMouse.x - m_iXmove;  
  819.     int  liYmove         = aoPtMouse.y - m_iYmove;  
  820.     m_oMovingRect        = m_oRect;  
  821.   
  822.     // 矫正  
  823.     RECT loRectParent;  
  824.     if (!m_pParentCtrl)   
  825.         ::GetClientRect(m_hWnd, &loRectParent);  
  826.     else   
  827.         loRectParent = m_pParentCtrl->GetRect();  
  828.   
  829.     if (m_oMovingRect.left < loRectParent.left)          liXmove = loRectParent.left - m_oMovingRect.left;  
  830.     if (m_oMovingRect.right > loRectParent.right)            liXmove = loRectParent.right - m_oMovingRect.right;  
  831.     if (m_oMovingRect.top < loRectParent.top)                liYmove = loRectParent.top - m_oMovingRect.top;  
  832.     if (m_oMovingRect.bottom > loRectParent.bottom)      liYmove = loRectParent.bottom - m_oMovingRect.bottom;  
  833.     // 平移  
  834.     m_oMovingRect.left      += liXmove;  
  835.     m_oMovingRect.right     += liXmove;  
  836.     m_oMovingRect.top       += liYmove;  
  837.     m_oMovingRect.bottom    += liYmove;  
  838.   
  839.     //  
  840.     RECT loRectUpdate = m_oRect;  
  841.     loRectUpdate.left   += m_liMaxLXmove;  
  842.     loRectUpdate.right  += m_liMaxRXmove;  
  843.     loRectUpdate.top    += m_liMaxUYmove;  
  844.     loRectUpdate.bottom += m_liMaxDYmove;  
  845.     // 更新  
  846.     ::InvalidateRect(m_hWnd, &loRectUpdate,TRUE);  
  847. }  
  848.   
  849.   
  850. void CUIBaseCtrl::IsChMouseOnBorder(POINT& aoPtMouse)  
  851. {  
  852.     // 如果落在非工作区域  
  853. //  if ( !IsPtInWorkRect(aoPtMouse))  
  854. //  {  
  855.         if (IsPtInLRect(aoPtMouse))  
  856.         {  
  857.             m_eCheckBordType = e_bIsCkLBorder;  
  858.             ::SetCursor(LoadCursor(NULL, IDC_SIZEWE));  
  859.             m_pMouseIcon = IDC_SIZEWE;  
  860.             m_bIsHitBorder  = TRUE;   
  861.         }  
  862.         else if( IsPtInRRect(aoPtMouse))  
  863.         {  
  864.             m_eCheckBordType = e_bIsCkRBorder;  
  865.             ::SetCursor(LoadCursor(NULL, IDC_SIZEWE));  
  866.             m_pMouseIcon = IDC_SIZEWE;  
  867.             m_bIsHitBorder  = TRUE;   
  868.               
  869.         }  
  870.         else if( IsPtInTRect(aoPtMouse))  
  871.         {  
  872.             m_eCheckBordType = e_bIsCkTBorder;  
  873.             ::SetCursor(LoadCursor(NULL, IDC_SIZENS));  
  874.             m_bIsHitBorder  = TRUE;   
  875.             m_pMouseIcon = IDC_SIZENS;  
  876.         }  
  877.         else if( IsPtInBRect(aoPtMouse))  
  878.         {  
  879.   
  880.             m_eCheckBordType = e_bIsCkBBorder;  
  881.             ::SetCursor(LoadCursor(NULL, IDC_SIZENS));  
  882.             m_bIsHitBorder  = TRUE;   
  883.             m_pMouseIcon = IDC_SIZENS;  
  884.         }  
  885.         else if( IsPtInLTRect(aoPtMouse))  
  886.         {  
  887.             m_eCheckBordType = e_bIsCkLTBorder;  
  888.             ::SetCursor(LoadCursor(NULL, IDC_SIZENWSE));  
  889.             m_bIsHitBorder  = TRUE;   
  890.             m_pMouseIcon = IDC_SIZENWSE;  
  891.         }  
  892.         else if( IsPtInRTRect(aoPtMouse))  
  893.         {  
  894.             m_eCheckBordType = e_bIsCkRTBorder;  
  895.             ::SetCursor(LoadCursor(NULL, IDC_SIZENESW));  
  896.             m_bIsHitBorder  = TRUE;   
  897.             m_pMouseIcon = IDC_SIZENESW;  
  898.         }  
  899.         else if( IsPtInLBRect(aoPtMouse))  
  900.         {   
  901.             m_eCheckBordType = e_bIsCkLBBorder;  
  902.             ::SetCursor(LoadCursor(NULL, IDC_SIZENESW));  
  903.             m_bIsHitBorder  = TRUE;  
  904.             m_pMouseIcon = IDC_SIZENESW;  
  905.         }  
  906.         else if( IsPtInRBRect(aoPtMouse))  
  907.         {  
  908.             m_eCheckBordType = e_bIsCkRBBorder;  
  909.             ::SetCursor(LoadCursor(NULL, IDC_SIZENWSE));  
  910.             m_bIsHitBorder  = TRUE;   
  911.             m_pMouseIcon = IDC_SIZENWSE;  
  912.         }  
  913.         return;  
  914.     //}  
  915.     m_eCheckBordType = e_bIsWorkRange;  
  916.     m_bIsHitBorder   = FALSE;  
  917.     m_pMouseIcon     = NULL;  
  918. }  
  919.   
  920. // 开始改变  
  921. void CUIBaseCtrl::BegSizeChange(POINT& aoPtMouse)  
  922. {  
  923.     // 如果边框被选中  
  924.     if (m_bIsHitBorder)  
  925.     {  
  926.         m_iXChange = aoPtMouse.x;  
  927.         m_iYChange = aoPtMouse.y;  
  928.         m_bInChangeSize = TRUE;  
  929.         m_oSCUpDateRect = m_oRect;  
  930.         ::SetCursor(LoadCursor(NULL, m_pMouseIcon));  
  931.     }  
  932. }  
  933.   
  934. void CUIBaseCtrl::OnLReSize(int aiXBefore, int aiXAfter, RECT& aoRedressRect, RECT& aoParentRect, int aiBorderSize)  
  935. {  
  936.     if ((aiXAfter - aiXBefore) < 0)  
  937.     {  
  938.         aoRedressRect.left -= (aiXBefore - aiXAfter);  
  939.         if(aoRedressRect.left < aoParentRect.left)   
  940.             aoRedressRect.left = aoParentRect.left;  
  941.     }  
  942.     else  
  943.     {  
  944.         aoRedressRect.left += (aiXAfter - aiXBefore);  
  945.         if (aoRedressRect.left > ( aoRedressRect.right - (aiBorderSize*3)))  
  946.             aoRedressRect.left = ( aoRedressRect.right - (aiBorderSize*3));  
  947.     }  
  948. }  
  949.   
  950. void CUIBaseCtrl::OnRReSize(int aiXBefore, int aiXAfter, RECT& aoRedressRect, RECT& aoParentRect, int aiBorderSize)  
  951. {  
  952.     if ((aiXAfter - aiXBefore) > 0)  
  953.     {  
  954.         aoRedressRect.right += (aiXAfter  - aiXBefore);  
  955.         if (aoRedressRect.right > aoParentRect.right)   
  956.             aoRedressRect.right = aoParentRect.right;  
  957.     }  
  958.     // 变小了  
  959.     else  
  960.     {  
  961.         aoRedressRect.right -= (aiXBefore - aiXAfter);  
  962.         if (aoRedressRect.right < ( aoRedressRect.left + (aiBorderSize*3)))  
  963.             aoRedressRect.right = ( aoRedressRect.left + (aiBorderSize*3));  
  964.     }  
  965. }  
  966.   
  967. void CUIBaseCtrl::OnTReSize(int aiYBefore, int aiYAfter, RECT& aoRedressRect, RECT& aoParentRect, int aiBorderSize)  
  968. {  
  969.     if (aiYAfter < aiYBefore)  
  970.     {  
  971.         aoRedressRect.top += (aiYAfter - aiYBefore);  
  972.         if (aoRedressRect.top < aoParentRect.top)  
  973.             aoRedressRect.top = aoParentRect.top;  
  974.     }  
  975.     else  
  976.     {  
  977.         aoRedressRect.top -= aiYBefore - aiYAfter;  
  978.         if (aoRedressRect.top > (aoRedressRect.bottom - (aiBorderSize*3)))  
  979.             aoRedressRect.top = aoRedressRect.bottom - (aiBorderSize*3);  
  980.     }  
  981. }  
  982.   
  983. void CUIBaseCtrl::OnBReSize(int aiYBefore, int aiYAfter, RECT& aoRedressRect, RECT& aoParentRect, int aiBorderSize)  
  984. {  
  985.     // 变大  
  986.     if (aiYAfter < aiYBefore)  
  987.     {  
  988.         aoRedressRect.bottom += (aiYAfter - aiYBefore);  
  989.         if (aoRedressRect.bottom < aoRedressRect.top +  (aiBorderSize*3))  
  990.             aoRedressRect.bottom = (aoRedressRect.top +  (aiBorderSize*3));  
  991.     }  
  992.     else  
  993.     {  
  994.         aoRedressRect.bottom += (aiYAfter - aiYBefore);  
  995.         if (aoRedressRect.bottom > aoParentRect.bottom)  
  996.             aoRedressRect.bottom = aoParentRect.bottom;  
  997.     }  
  998. }  
  999. //GetDesktopWindow  
  1000. //GetWindowRect  
  1001. // 绘制变化时区域  
  1002. void CUIBaseCtrl::DrawChangeRect(POINT& aoPtMouse)  
  1003. {  
  1004.     if (!m_bInChangeSize)  
  1005.     {  
  1006.         IsChMouseOnBorder(aoPtMouse);  
  1007.         return;  
  1008.     }  
  1009.     // 设置鼠标状态  
  1010.     ::SetCursor(LoadCursor(NULL, m_pMouseIcon));  
  1011.     if (!m_pParentCtrl)  
  1012.         ::GetClientRect(m_hWnd, &m_oMovingRect);  
  1013.     else  
  1014.         m_oMovingRect = m_oRect;  
  1015.   
  1016.     HWND lhTopWnd = NULL;  
  1017.     RECT loParentRect;  
  1018.     if (m_pParentCtrl)  
  1019.     {  
  1020.         loParentRect = m_pParentCtrl->GetRect();  
  1021.         loParentRect.left   += m_pParentCtrl->GetBorderSize();  
  1022.         loParentRect.right  -= m_pParentCtrl->GetBorderSize();  
  1023.         loParentRect.top    += m_pParentCtrl->GetBorderSize();  
  1024.         loParentRect.bottom += m_pParentCtrl->GetBorderSize();  
  1025.     }  
  1026.     else   
  1027.         ::GetClientRect(m_hWnd, &loParentRect);  
  1028. //  {  
  1029. //      lhTopWnd  = ::GetDesktopWindow();  
  1030. //      ::GetClientRect(lhTopWnd, &loParentRect);  
  1031. //  }  
  1032.   
  1033.     switch (m_eCheckBordType)  
  1034.     {  
  1035.     case e_bIsCkLBorder:    // 选中左边框  
  1036.         OnLReSize(m_iXChange, aoPtMouse.x , m_oMovingRect, loParentRect, m_iBorderSize);  
  1037.         break;  
  1038.     case e_bIsCkRBorder:    // 选中右边框  
  1039.         OnRReSize(m_iXChange, aoPtMouse.x , m_oMovingRect, loParentRect, m_iBorderSize);  
  1040.         break;        
  1041.     case e_bIsCkTBorder:    // 选中上边框      
  1042.         OnTReSize(m_iYChange, aoPtMouse.y ,m_oMovingRect, loParentRect, m_iBorderSize);  
  1043.         break;  
  1044.     case e_bIsCkBBorder:    // 选中下边框  
  1045.         OnBReSize(m_iYChange, aoPtMouse.y ,m_oMovingRect, loParentRect, m_iBorderSize);  
  1046.         break;  
  1047.     case e_bIsCkLTBorder:   // 选中左顶点  
  1048.         OnLReSize(m_iXChange, aoPtMouse.x , m_oMovingRect, loParentRect, m_iBorderSize);  
  1049.         OnTReSize(m_iYChange, aoPtMouse.y ,m_oMovingRect, loParentRect, m_iBorderSize);  
  1050.         break;  
  1051.     case e_bIsCkRTBorder:   // 选中右顶点  
  1052.         OnRReSize(m_iXChange, aoPtMouse.x , m_oMovingRect, loParentRect, m_iBorderSize);  
  1053.         OnTReSize(m_iYChange, aoPtMouse.y ,m_oMovingRect, loParentRect, m_iBorderSize);  
  1054.         break;  
  1055.     case e_bIsCkLBBorder:   // 选中左底点  
  1056.         OnLReSize(m_iXChange, aoPtMouse.x , m_oMovingRect, loParentRect, m_iBorderSize);  
  1057.         OnBReSize(m_iYChange, aoPtMouse.y ,m_oMovingRect, loParentRect, m_iBorderSize);  
  1058.         break;  
  1059.     case e_bIsCkRBBorder:   // 选中右底点  
  1060.         OnRReSize(m_iXChange, aoPtMouse.x , m_oMovingRect, loParentRect, m_iBorderSize);  
  1061.         OnBReSize(m_iYChange, aoPtMouse.y ,m_oMovingRect, loParentRect, m_iBorderSize);  
  1062.         break;  
  1063.     default:  
  1064.         {  
  1065.             m_bIsHitBorder  = 0;  
  1066.             m_bInChangeSize = 0;  
  1067.             m_pMouseIcon    = 0;  
  1068.         }  
  1069.         break;  
  1070.     }  
  1071.   
  1072.     // 更新  
  1073.     if (m_oSCUpDateRect.left    > m_oMovingRect.left)  
  1074.         m_oSCUpDateRect.left    =  m_oMovingRect.left;  
  1075.   
  1076.     if (m_oSCUpDateRect.right   < m_oMovingRect.right)  
  1077.         m_oSCUpDateRect.right   = m_oMovingRect.right;  
  1078.   
  1079.     if (m_oSCUpDateRect.top     > m_oMovingRect.top)  
  1080.         m_oSCUpDateRect.top     = m_oMovingRect.top;  
  1081.   
  1082.     if (m_oSCUpDateRect.bottom  < m_oMovingRect.bottom)  
  1083.         m_oSCUpDateRect.bottom  = m_oMovingRect.bottom;  
  1084.   
  1085.   
  1086. //      if (lhTopWnd)  
  1087. //          ::InvalidateRect(lhTopWnd, &loParentRect,TRUE);  
  1088. //      else  
  1089.         ::InvalidateRect(m_hWnd, &m_oSCUpDateRect,TRUE);  
  1090. }  
  1091.   
  1092. // 结束改变  
  1093. void CUIBaseCtrl::EndSizeChange(POINT& aoPtMouse)  
  1094. {  
  1095.     if (!m_bInChangeSize)  
  1096.     {  
  1097.         IsChMouseOnBorder(aoPtMouse);  
  1098.         return;  
  1099.     }  
  1100.     // 设置鼠标状态  
  1101.     RECT loTempRect = m_oRect;  
  1102.     RECT loParentRect;  
  1103.     if (m_pParentCtrl)  
  1104.     {  
  1105.         loParentRect = m_pParentCtrl->GetRect();  
  1106.         loParentRect.left   += m_pParentCtrl->GetBorderSize();  
  1107.         loParentRect.right  -= m_pParentCtrl->GetBorderSize();  
  1108.         loParentRect.top    += m_pParentCtrl->GetBorderSize();  
  1109.         loParentRect.bottom += m_pParentCtrl->GetBorderSize();  
  1110.     }  
  1111.     else ::GetClientRect(m_hWnd, &loParentRect);  
  1112.   
  1113.     switch (m_eCheckBordType)  
  1114.     {  
  1115.     case e_bIsCkLBorder:    // 选中左边框  
  1116.         OnLReSize(m_iXChange, aoPtMouse.x , loTempRect, loParentRect, m_iBorderSize);  
  1117.         break;  
  1118.     case e_bIsCkRBorder:    // 选中右边框  
  1119.         OnRReSize(m_iXChange, aoPtMouse.x , loTempRect, loParentRect, m_iBorderSize);  
  1120.         break;        
  1121.     case e_bIsCkTBorder:    // 选中上边框      
  1122.         OnTReSize(m_iYChange, aoPtMouse.y ,loTempRect, loParentRect, m_iBorderSize);  
  1123.         break;  
  1124.     case e_bIsCkBBorder:    // 选中下边框  
  1125.         OnBReSize(m_iYChange, aoPtMouse.y ,loTempRect, loParentRect, m_iBorderSize);  
  1126.         break;  
  1127.     case e_bIsCkLTBorder:   // 选中左顶点  
  1128.         OnLReSize(m_iXChange, aoPtMouse.x , loTempRect, loParentRect, m_iBorderSize);  
  1129.         OnTReSize(m_iYChange, aoPtMouse.y ,loTempRect, loParentRect, m_iBorderSize);  
  1130.         break;  
  1131.     case e_bIsCkRTBorder:   // 选中右顶点  
  1132.         OnRReSize(m_iXChange, aoPtMouse.x , loTempRect, loParentRect, m_iBorderSize);  
  1133.         OnTReSize(m_iYChange, aoPtMouse.y ,loTempRect, loParentRect, m_iBorderSize);  
  1134.         break;  
  1135.     case e_bIsCkLBBorder:   // 选中左底点  
  1136.         OnLReSize(m_iXChange, aoPtMouse.x , loTempRect, loParentRect, m_iBorderSize);  
  1137.         OnBReSize(m_iYChange, aoPtMouse.y ,loTempRect, loParentRect, m_iBorderSize);  
  1138.         break;  
  1139.     case e_bIsCkRBBorder:   // 选中右底点  
  1140.         OnRReSize(m_iXChange, aoPtMouse.x , loTempRect, loParentRect, m_iBorderSize);  
  1141.         OnBReSize(m_iYChange, aoPtMouse.y ,loTempRect, loParentRect, m_iBorderSize);  
  1142.         break;  
  1143.     default:  
  1144.         break;  
  1145.     }  
  1146.     // 更新  
  1147.     if (m_oSCUpDateRect.left   > loTempRect.left)        m_oSCUpDateRect.left    =  loTempRect.left;  
  1148.     if (m_oSCUpDateRect.right  < loTempRect.right)       m_oSCUpDateRect.right   =  loTempRect.right;  
  1149.     if (m_oSCUpDateRect.top    > loTempRect.top)     m_oSCUpDateRect.top     =  loTempRect.top;  
  1150.     if (m_oSCUpDateRect.bottom < loTempRect.bottom)      m_oSCUpDateRect.bottom  =  loTempRect.bottom;  
  1151.   
  1152.     SetRect(loTempRect);  
  1153.   
  1154.     m_bIsHitBorder  = 0;  
  1155.     m_bInChangeSize = 0;  
  1156.     m_pMouseIcon    = 0;  
  1157.     ::InvalidateRect(m_hWnd, &m_oSCUpDateRect,TRUE);  
  1158. }     
  1159.   
  1160.   
  1161. void CUIBaseCtrl::OnMaxRestore(void)  
  1162. {  
  1163.     if (m_pParentCtrl)  
  1164.         m_pParentCtrl->OnMaxRestore();  
  1165.     else  
  1166.     {  
  1167.         if (SW_MAXIMIZE == m_iStytle )  
  1168.         {  
  1169.             m_iStytle = SW_RESTORE;  
  1170.             ::MoveWindow( m_hWnd, m_oRectBefore.left,   
  1171.                           m_oRectBefore.top,  
  1172.                           m_oRectBefore.right  - m_oRectBefore.left,  
  1173.                           m_oRectBefore.bottom - m_oRectBefore.top,  
  1174.                           TRUE);  
  1175.             m_iStytle = SW_RESTORE;  
  1176.         }  
  1177.         else   
  1178.         {  
  1179.             m_iStytle = SW_MAXIMIZE;  
  1180.             RECT    Screen;  
  1181.             GetWindowRect(m_hWnd,&m_oRectBefore);  
  1182.             SystemParametersInfo(SPI_GETWORKAREA,0,&Screen,0);  
  1183.             ::MoveWindow( m_hWnd, Screen.left,   
  1184.                           Screen.top,   
  1185.                           Screen.right,  
  1186.                           Screen.bottom,  
  1187.                           TRUE);  
  1188.         }  
  1189.     }  
  1190. }  
  1191.   
  1192. int CUIBaseCtrl::GetStytle(void)  
  1193. {  
  1194.     if (NULL != m_pParentCtrl)  
  1195.         return m_pParentCtrl->GetStytle();  
  1196.     return m_iStytle;  
  1197. }  
  1198.   
  1199. void CUIBaseCtrl::OnOCMCommand(S_MsgEventUI& apEvent)  
  1200. {  
  1201.   
  1202. }  
  1203.   
  1204. void CUIBaseCtrl::SetWndText(TCHAR* apText)  
  1205. {  
  1206.     if (apText)  
  1207.         m_strWinText = apText;  
  1208. }  
  1209.   
  1210. 代码实现的很烂，稍后再做调整和优化，目前的目标，就是实现功能。  
[cpp] view plain copy print ?
  1. 由此基类派生出具体的控件，目前可以使用的包括：  
[cpp] view plain copy print ?
  1.  CUIAreaCtrl      区域  
  2.   
  3.  CUIPicAreaCtrl   图片区域  
  4.   
  5.  CUIButtonCtrl    按钮  
  6.   
  7.  CUIProgressCtrl  进度条  
  8.   
  9.  CUITextCtrl&nbsp 文本框  
  10.   
  11.  CUITitleBarCtrl  台头  
  12.   
  13.  CUITreeCtrl      树 --- 进行中ing  
  14.   
  15.  其中也CUITreeCtrl 的实现较为复杂，现在还在进行中，其具体定义如下：  
[cpp] view plain copy print ?
  1.    
[cpp] view plain copy print ?
  1.    
[cpp] view plain copy print ?
  1. /* CLASS_BEGIN ***************************************************** 
  2.    类名：CUITreeCtrl 
  3.    功能：树控件 
  4.    说嘛：目前用链表实现了这颗树是否合理有待验证 
  5.    CLASS_END  ******************************************************/  
  6. #ifndef H_UITREECTRL_H  
  7. #define H_UITREECTRL_H  
  8. #include "UIBaseCtrl.h"  
  9.   
  10. // 节点状态  
  11. enum E_TNodeStatu  
  12. {  
  13.     e_Statu_Shrink  = 0,    // 收缩状态  
  14.     e_Statu_Stretch,        // 伸展状态  
  15.     e_Statu_Hide,           // 隐藏状态  
  16. };  
  17.   
  18. class CUITreeCtrl;  
  19. // 树节点  
  20. class CUITreeNodeCtrl : public CUIBaseCtrl  
  21. {  
  22. public:  
  23.     CUITreeNodeCtrl(CUICache* apCache, CWinWnd* apWinWnd);  
  24.     ~CUITreeNodeCtrl(void);  
  25.   
  26. public:  
  27.     // 设置Y顶点位置  
  28.     int SetYVertex(SInt32 aiYVertex);  
  29.     // 设置节点高度  
  30.     void SetNodeHigth(SInt32 aiNodeHigth);  
  31.     // 获取节点高度  
  32.     SInt32 GetNodeHigth(void);  
  33.     // 绘制  
  34.     virtual void OnPaint(HDC ahDC, const RECT& aoRect, S_MsgEventUI& apEvent);       
  35. protected:  
  36.     // 绘制背景  
  37.     virtual void PaintBkColor(HDC ahDC);      
  38.     // 绘制背景图片  
  39.     virtual void PaintBkImage(HDC ahDC);  
  40.     // 绘制状态图  
  41.     virtual void PaintGdiplusImage(HDC hDC);  
  42.     // 绘制文字  
  43.     virtual void PaintText(HDC hDC);  
  44.     // 绘制边框  
  45.     virtual void PaintBorder(HDC hDC);                                                
  46. private:      
  47.     friend class CUITreeCtrl;  
  48.     SInt32                                  m_iNodeHigth;           // 节点高度  
  49.     SInt32                                  m_iYVertex;             // Y顶点位置  
  50.     E_TNodeStatu                            m_eTNodeStatu;          // 节点状态  
  51.     CUITreeNodeCtrl*                        m_pNodeUp;              // 上一个节点  
  52.     CUITreeNodeCtrl*                        m_pNodeDown;            // 下一个节点  
  53.     CUITreeCtrl*                            m_pChildTree;           // 节点可以连接子树  
  54.     BOOL                                    m_bIsChoose;            // 是否被选中  
  55.   
  56. };  
  57.   
  58. // 树控件  
  59. class CUITreeCtrl : public CUIBaseCtrl  
  60. {  
  61. public:  
  62.     CUITreeCtrl(CUICache* apCache, CWinWnd* apWinWnd);  
  63.     ~CUITreeCtrl(void);  
  64.     friend class CUITreeNodeCtrl;  
  65. public:  
  66.   
  67.     // 增加节点到指定节点上方  
  68.     CUITreeNodeCtrl* AddNodeUp(CUITreeNodeCtrl* apConnectNode/* = NULL*/);  
  69.   
  70.     // 增加节点到指定节点下方  
  71.     CUITreeNodeCtrl* AddNodeDown(CUITreeNodeCtrl* apConnectNode/* = NULL*/);  
  72.   
  73.     // 增加子节点到指定节点下方  
  74.     CUITreeNodeCtrl* AddNodeChild(CUITreeNodeCtrl* apConnectNode/* = NULL*/);  
  75.   
  76.     // 删除指定节点  
  77.     BOOL DeleteNode(CUITreeNodeCtrl*& apChildNode);  
  78.   
  79.     // 检查子节点是否属于  
  80.     BOOL IsCTNode(CUITreeNodeCtrl* apChildTNode, CUITreeNodeCtrl* apFaterNode);  
  81.   
  82.     // 查询子树  
  83.     CUITreeCtrl* FindChildTree(CUITreeNodeCtrl* apCurNode);  
  84.   
  85.     // 查询首节点  
  86.     CUITreeNodeCtrl* FindHeadNode(void);  
  87.   
  88.     // 查询尾节点  
  89.     CUITreeNodeCtrl* FindTailNode(void);  
  90.   
  91.     // 查询下一个节点  
  92.     CUITreeNodeCtrl* FindUpNode(CUITreeNodeCtrl* apCurNode);  
  93.   
  94.     // 查询下一个节点  
  95.     CUITreeNodeCtrl* FindDownNode(CUITreeNodeCtrl* apCurNode);  
  96.    
  97.     // 重新计算所有节点的位置  
  98.     int ResetNodePos(int aiStartPos = 0);  
  99.   
  100.     // 绘制  
  101.     virtual void OnPaint(HDC ahDC, const RECT& aoRect, S_MsgEventUI& apEvent);   
  102.   
  103.     // 计算控件大小  
  104.     void CacuRectSize(RECT& loWorkRect);  
  105.   
  106. private:  
  107.     //  首节点  
  108.     CUITreeNodeCtrl*                        m_pHeadNodeCtrl;  
  109.     //  尾节点  
  110.     CUITreeNodeCtrl*                        m_pTailNodeCtrl;  
  111.     //  线程安全  
  112.     CThreadLock                             m_oTreeLock;  
  113.     //  是否是顶层控件  
  114.     BOOL                                    m_bIsTopCtrl;  
  115. };  
  116.   
  117. #endif//H_UITREECTRL_H  

由于没有想到好的方式来处理树的底层数据结构, 目前采用的是双向链表 + 子链表的方式来实现, 待完成后看看效率是否达标吧。

忘各位大神能提好的意见，建议。最初我的想法是Set+List 方式，但是数据维护过于繁琐。

截几个图片：

 

[cpp] view plain copy print ?
  1.  
Marcelxx
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【虚拟仿真】Unity3D中实现2DUI显示在3D物体旁边
CSDN博客专家，Unity3D高级软件工程师，《Unity 3D从入门到实战》作者。
07-31 279
这篇文章来实现2DUI显示在3D物体旁边，当我们需要在3D模型旁边显示2DUI的时候，比如人物的对话、物体旁边的说明面板会用到。
Windows窗口编程中的WM_PAINT、WM_ERASEBKGND、InvalidateRect、UpdateWindow、BeginPaint和EndPaint等函数详解
最新发布
dvlinker的技术专栏
06-09 6676
Windows窗口编程中的WM_PAINT、WM_ERASEBKGND、InvalidateRect、UpdateWindow、BeginPaint和EndPaint等函数详解
DUI入门
wenhong609的专栏
06-03 2930
要使用duilib库，必须把库导入，代码如下： 1 #include “xxxUIlib.h“//xxx为UIlib.h的路径 2 using namespace Duilib; //Duilib为库自定义的名字空间 3 4 #ifdef _DEBUG 5 #ifdef _UNICODE 6 #pragma comment(lib, “xxxDuilib_ud.lib”) 7
duilib入门
youyudexiaowangzi的专栏
12-21 541
duilib入门 git地址https://github.com/duilib/duilib 环境vs2017 编译错误: duilib提示缺少v120_xp， 右键DuiLib.vcxproj用notepad++打开，把所有的v120_xp替换为v141 右键DuiLib_Static.vcxproj用notepad++打开，把所有的v120_xp替换为v141 提示无法打开StdAfx.h...
DuiLib 之 UIControl
不积跬步无以至千里不积小流无以成江海
07-09 6464
#ifndef __UICONTROL_H__ #define __UICONTROL_H__ #pragma once namespace DuiLib { ///////////////////////////////////////////////////////////////////////////////////// // typedef CControlUI* (CALLBA
Android【Fresco】 使用的详解（二）
女程序媛的自我修养
05-13 8564
上次说了Fresco的基本使用方式 这次来说说，Fresco的更多使用设置缩放类型实际图片，占位图，重试图和失败图都可以在 xml 中进行设置，用 fresco:actualImageScaleType 这样的属性。你也可以使用 GenericDraweeHierarchyBuilder 类在代码中进行设置。其中可用的缩放类型如下center 居中，无缩放。 centerCrop 保持宽高比
Java 边框类型setBorder BorderFactory
weixin_41999297的博客
05-18 3218
import java.awt.*; import javax.swing.*; import javax.swing.border.*; public class BorderDemo { public static void main(String[] args) { JFrame frame = new JFrame("Swing边框演示"); frame.setDefaultCloseOperation(JFrame.EXIT_ON_C
DUI引擎属性文档1
08-08
以下是一些核心的DUI引擎属性及其详细说明： 1. **模版属性 (baseClass)**: 定义在`duiobject.h`文件中，`baseClass`属性用于指定一个类模板，这意味着该UI元素将继承自这个类模板的所有特性。 2. **风格属性**: ...
光谱学中用于计算强度相关性和结构函数的LabView工具箱
国立理工学院2508，07360墨西哥城，墨西哥ar t i cl e i nf o文章历史：已收到22六月2020年收到修订表格2020年11月26日接受2020年关键词：强度相关（结构）函数动态光散射（DUI）光子相关光谱学[编辑]a b st ra ct...
FreeRTOS-CortexM4-相关函数说明
plingx的博客
07-12 593
目录 0. FreeRTOS配置 1. void prvStartFirstTask( void ) 2. void vPortSVCHandler( void ) 3. void xPortPendSVHandler( void ) 4. StackType_t *pxPortInitialiseStack( StackType_t *pxTopOfStack, TaskFunctio...
duilib 环形进度条
03-20
duilib 自定义环形进度条 用gdi+ 自绘制
Duilib源码分析(四)绘制管理器—CPaintManagerUI—(前期准备二)
diansiji9321的博客
11-02 337
　　接下来，我们继续分析UIlib.h文件中余下的文件，当然部分文件可能顺序错开分析，这样便于从简单到复杂的整个过程的里面，而避免一开始就出现各种不理解的地方。 　　1. UIManager.h：UI管理器，暂时放在后面介绍； 　　2. UIBase.h：UI窗口相关，包括常用的窗口风格、窗口类风格的宏定义，调试相关，以及基本窗口类； 　　　　首先宏定义了几个常用的窗口风格、窗口扩...
Duilib 源码分析之 CControlUI 篇
Aloe_Jinchx的博客
12-14 4859
今天来介绍一下 Duilib 中所有类型控件的基类： CControlUI，后续后陆续介绍各个不同的控件的实现。对于基类 CControlUI 主要介绍下共通的方法和属性 (由于本人水平有限，以下内容只是个人见解，仅供参考，如有错误请指正，不胜感激，本贴基于 Duilib 的版本是 “Duilib 开源项目圈2群” 中下载的版本，在代码上可能会有些出入) CDuiString GetName()
关于duilib的理解
03-06 2068
0 duilib文件(5/17)   [x] stb_image.c   [x] stdafx.h stdafx.cpp   [ ] UIActiveX.h UIActiveX.cpp   [x] UIBase.h UIBase.cpp   [ ] UICombo.h UICombo.cpp   [x] UICommonControls.h UICommonControls.cpp
duilib学习笔记
热门推荐
mergerly的专栏
01-31 1万+
前段时间对皮肤引擎比较感兴趣，于是在VS第一人称快的无法直视的dot大神推荐下，看了一个小巧又好用的皮肤引擎：duilib。 1. duilib简介 duilib是一个开源的DirectUI界面库，简洁但是功能强大。而且还是BSD的license，所以即便是在商业上，大家也可以安心使用。 现在大家可以从这个网站获取到他们所有的源码：http://code.google.com/p/d
DuiLib库
12-06 2850
DuiLib库 我们把它分为四个模块（核心，基础，控件，另外的库），当前有些也会把它分为5个模块（用户界面层，数据，事件处理，渲染模块，插件模块） 我们先讲下四个模块里包含了那些类 一.核心模块：UIMarkup(解析XML)， CMarkupNode（节点），CRenderClip（渲染区域控制）， CRenderEngine（渲染引擎）， CPaintManagerUI（绘制管理者），
DUI总结
weixin_30650039的博客
04-06 253
DUI好处在于可以很方便的构建高效，绚丽的，非常易于扩展的界面。从而很好的将界面和逻辑分离，同时易于实现各种超炫的界面效果如换色，换肤，透明等。DUI使用的是GDI+核心.DirectUI可以理解为一个轻量级的WPF，可以让C++做出C#般绚丽的界面。 DUI核心的大体结构图如下： 分为几个大部分： 1.控件 2.容器 3.UI构建解析器（XML解析） ...
duidemo梳理
qq_39870425的博客
01-17 406
duidemo梳理
duilib之源码分析
qinwei4072880的专栏
04-05 1470
《duilib之源码分析》 1 stdAfx.h * lengthof(x) 计算数组长度宏 * MAX  两值最大 * MIN  两值最小 * CLAMP(x,a,b) x在a,b之间则取x否则取最小 2 UIBase * UI_WNDSTYLE_ 窗口风格属性 * UI_CLASSSTYLE_ 窗口类属性 * TRACE(LPCTSTR pstrFormat, ...)
ue4中3DUI属性绑定
06-08
6. 在蓝图中，在构造函数或其他适当的位置，使用“Set Property”节点将属性绑定到UMG中的控件。 7. 在场景中移动对象时，UMG中的控件将自动更新以反映对象的属性。 注意：绑定属性需要一定的蓝图编程知识。如果您...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值