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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 界面编程 > 查看源码
RTDialog.cpp
资源名称：20060417006-9709.rar　[点击查看]
上传用户：qhonly
上传日期：2013-06-10
资源大小：487k
文件大小：28k
源码类别：

界面编程

开发平台：

Visual C++

RTDialog.cpp：源码内容
  1. // RTDialog.cpp : 实现文件
  2. //
  4. #include "stdafx.h"
  5. #include "RTDialog.h"
  6. #include "RTDraw.h"
  7. #include "RTMenu.h"
  8. // CRTDialog 对话框
  10. IMPLEMENT_DYNAMIC(CRTDialog, CDialog)
  11. IMPLEMENT_MENUXP(CRTDialog,CDialog)
  12. CRTDialog::CRTDialog()
  13. : CDialog()
  14. {
  15. m_bActive = FALSE;
  17. m_ExitButtonState = StateNormal;
  18. m_MinimizeButtonState = StateNormal;
  19. m_MaximizeButtonState = StateNormal;
  20. m_NcMouseState = MouseStateNormal;
  21. m_SelTitleButton = NoneButton;
  22. }
  24. CRTDialog::CRTDialog(UINT uTemplate,CWnd *pParent)
  25. : CDialog(uTemplate,pParent)
  26. {
  27. m_bActive = FALSE;
  29. m_ExitButtonState = StateNormal;
  30. m_MinimizeButtonState = StateNormal;
  31. m_MaximizeButtonState = StateNormal;
  32. m_NcMouseState = MouseStateNormal;
  33. m_SelTitleButton = NoneButton;
  34. }
  35. CRTDialog::CRTDialog(LPCTSTR lpszTemplateName,CWnd* pParent)
  36. : CDialog(lpszTemplateName,pParent)
  37. {
  38. m_bActive = FALSE;
  40. m_ExitButtonState = StateNormal;
  41. m_MinimizeButtonState = StateNormal;
  42. m_MaximizeButtonState = StateNormal;
  43. m_NcMouseState = MouseStateNormal;
  44. m_SelTitleButton = NoneButton;
  45. }
  46. CRTDialog::~CRTDialog()
  47. {
  48. }
  50. COLORREF CRTDialog::m_BorderColor[4] = {0xAD9E9C,0xCEBEB5,0xCEBEB5,0xDED3CE};
  51. BOOL     CRTDialog::m_bEnableSkin = FALSE;
  52. BOOL     CRTDialog::m_bEnableBack = FALSE;
  53. BOOL     CRTDialog::m_bEnableBorder = FALSE;
  54. BOOL     CRTDialog::m_bEnableTitleBar = FALSE;
  55. CBitmap* CRTDialog::m_TitleBarBitmap[5] = {NULL,NULL,NULL,NULL,NULL};
  56. CBitmap* CRTDialog::m_MenuBarBitmap[5] = {NULL,NULL,NULL,NULL,NULL};
  57. CBitmap* CRTDialog::m_MaximizeButtonBitmap[5] = {NULL,NULL,NULL,NULL,NULL};
  58. CBitmap* CRTDialog::m_MinimizeButtonBitmap[5] = {NULL,NULL,NULL,NULL,NULL};
  59. CBitmap* CRTDialog::m_RestoreButtonBitmap[5] ={ NULL,NULL,NULL,NULL,NULL};
  60. CBitmap* CRTDialog::m_ExitButtonBitmap[5] = {NULL,NULL,NULL,NULL,NULL};
  63. UINT     CRTDialog::m_TitleBarBitmapDrawMode[5] = {0,0,0,0,0};
  64. UINT     CRTDialog::m_MenuBarBitmapDrawMode[5] = {0,0,0,0,0};
  65. UINT     CRTDialog::m_MaximizeButtonBitmapDrawMode[5] = {0,0,0,0,0};
  66. UINT     CRTDialog::m_MinimizeButtonBitmapDrawMode[5] = {0,0,0,0,0};
  67. UINT     CRTDialog::m_ExitButtonBitmapDrawMode[5] = {0,0,0,0,0};
  68. UINT     CRTDialog::m_RestoreButtonBitmapDrawMode[5] = {0,0,0,0,0};
  70. void CRTDialog::DoDataExchange(CDataExchange* pDX)
  71. {
  72. CDialog::DoDataExchange(pDX);
  73. }
  76. BEGIN_MESSAGE_MAP(CRTDialog, CDialog)
  77. END_MESSAGE_MAP()
  80. // CRTDialog 消息处理程序
  81. BOOL CRTDialog::RTDrawFrameBorder(CDC *pDC,HRGN hrgn)
  82. {
  83. //画框架
  84. CRect rtWnd;
  85. GetWindowRect(&rtWnd);
  87. int Frame_BorderWidth = GetSystemMetrics(SM_CXDLGFRAME);
  88. int Frame_BorderHeight =GetSystemMetrics(SM_CYDLGFRAME);
  90. if(!m_bEnableBorder)
  91. {
  92. HRGN rgn = NULL;
  94. //left border
  95. rgn = CreateRectRgn(rtWnd.left,rtWnd.top,rtWnd.left + Frame_BorderWidth,rtWnd.bottom);
  96. if(hrgn != NULL)
  97. {
  98. if(NULLREGION != CombineRgn(rgn,rgn,hrgn,RGN_AND))
  99. {
  100. CDialog::WindowProc(WM_NCPAINT,(WPARAM)rgn,0);
  101. }
  102. }
  103. else
  104. {
  105. CDialog::WindowProc(WM_NCPAINT,(WPARAM)rgn,0);
  106. }
  107. DeleteObject(rgn);
  109. //top border
  110. rgn = CreateRectRgn(rtWnd.left,rtWnd.top,rtWnd.right,rtWnd.top + Frame_BorderHeight);
  111. if(hrgn != NULL && NULLREGION != CombineRgn(rgn,rgn,hrgn,RGN_AND))
  112. {
  113. CDialog::WindowProc(WM_NCPAINT,(WPARAM)rgn,0);
  114. }
  115. else
  116. {
  117. CDialog::WindowProc(WM_NCPAINT,(WPARAM)rgn,0);
  118. }
  119. DeleteObject(rgn);
  121. //right border
  122. rgn = CreateRectRgn(rtWnd.right - Frame_BorderWidth,rtWnd.top,rtWnd.right,rtWnd.bottom);
  123. if(hrgn != NULL && NULLREGION != CombineRgn(rgn,rgn,hrgn,RGN_AND))
  124. {
  125. CDialog::WindowProc(WM_NCPAINT,(WPARAM)rgn,0);
  126. }
  127. else
  128. {
  129. CDialog::WindowProc(WM_NCPAINT,(WPARAM)rgn,0);
  130. }
  131. DeleteObject(rgn);
  133. //bottom
  134. rgn = CreateRectRgn(rtWnd.left,rtWnd.bottom - Frame_BorderHeight,rtWnd.right,rtWnd.bottom);
  135. if(hrgn != NULL && NULLREGION != CombineRgn(rgn,rgn,hrgn,RGN_AND))
  136. {
  137. CDialog::WindowProc(WM_NCPAINT,(WPARAM)rgn,0);
  138. }
  139. else
  140. {
  141. CDialog::WindowProc(WM_NCPAINT,(WPARAM)rgn,0);
  142. }
  143. DeleteObject(rgn);
  144. return TRUE;
  145. }
  147. CRect rtBorder;
  148. rtBorder.SetRect(0,0,rtWnd.Width(),rtWnd.Height());
  149. //画立体边框
  151. for(int i = 0; i < Frame_BorderWidth ; i ++)
  152. {
  153. if(i < 4)
  154. {
  155. pDC->Draw3dRect(i,i,rtWnd.Width() - 2*i,rtWnd.Height() - 2*i,m_BorderColor[i],m_BorderColor[i]);
  156. }
  157. else
  158. {
  159. pDC->Draw3dRect(i,i,rtWnd.Width() - 2*i,rtWnd.Height() - 2*i,m_BorderColor[3],m_BorderColor[3]);
  160. }
  161. }
  163. return TRUE;
  164. }
  167. BOOL CRTDialog::RTDrawMenuBar(CDC *pDC,LPARAM lParam,HRGN hrgn)
  168. {
  169. CMenu *pMenu = GetMenu();
  170. if(pMenu == NULL)return TRUE;
  172. CRect rtMenu;
  173. CRect rtWnd;
  174. DWORD style = GetStyle();
  175. int BorderWidth = 0;
  176. int BorderHeight = 0;
  177. int CaptionHeight = 0;
  179. BorderWidth = GetSystemMetrics(SM_CXDLGFRAME);
  180. BorderHeight =GetSystemMetrics(SM_CYDLGFRAME);
  182. //no support toolswindow
  183. if((style & WS_CAPTION) == WS_CAPTION)
  184. {
  185. CaptionHeight = GetSystemMetrics(SM_CYCAPTION);
  186. }
  188. GetWindowRect(&rtWnd);
  189. rtMenu.left = GetSystemMetrics(SM_CXFRAME);
  190. rtMenu.top = GetSystemMetrics(SM_CYSIZE) + GetSystemMetrics(SM_CXFRAME) + 1;
  191. rtMenu.right = rtWnd.Width() - GetSystemMetrics(SM_CXFRAME);
  192. rtMenu.bottom = rtMenu.top +  GetSystemMetrics(SM_CYMENU);
  194. UINT ItemCount = pMenu->GetMenuItemCount();
  196. int PrevTop = rtMenu.top;
  197. int PrevLeft = rtMenu.left;
  198. int MenuItemHeight = GetSystemMetrics(SM_CYMENU);
  199. CRect rtMenuItem;
  201. //画菜单上部线
  202. CBrush brMenu(GetSysColor(COLOR_MENU));
  203. CBrush* pOldBrush = pDC->SelectObject(&brMenu);
  204. pDC->PatBlt(rtMenu.left,rtMenu.top - 1,rtMenu.Width(),1, PATCOPY);
  206. for(UINT items = 0; items < ItemCount; items++)
  207. {
  208. GetMenuItemRect(m_hWnd,pMenu->m_hMenu,items,&rtMenuItem);
  210. //画系统菜单
  211. HRGN rgn = CreateRectRgn(rtMenuItem.left,rtMenuItem.top,rtMenuItem.right,rtMenuItem.bottom);
  212. if(hrgn != NULL)
  213. {
  214. if(NULLREGION != CombineRgn(rgn,rgn,hrgn,RGN_AND))
  215. {
  216. CDialog::WindowProc(WM_NCPAINT,(WPARAM)rgn,0);
  217. }
  218. }
  219. else
  220. {
  221. CDialog::WindowProc(WM_NCPAINT,(WPARAM)rgn,0);
  222. }
  223. DeleteObject(rgn);
  225. int MenuTop = rtMenuItem.top - rtWnd.top;
  226. MenuItemHeight = rtMenuItem.Height();
  227. if(MenuTop != PrevTop)
  228. {
  229. if(!CRTMenu::m_bEnableSkin)
  230. {
  231. rgn = CreateRectRgn(rtWnd.left + PrevLeft,rtWnd.top + PrevTop,rtWnd.right - BorderWidth,rtWnd.top + PrevTop + MenuItemHeight);
  232. if(hrgn != NULL)
  233. {
  234. if(NULLREGION != CombineRgn(rgn,rgn,hrgn,RGN_AND))
  235. {
  236. CDialog::WindowProc(WM_NCPAINT,(WPARAM)rgn,0);
  237. }
  238. }
  239. else
  240. {
  241. CDialog::WindowProc(WM_NCPAINT,(WPARAM)rgn,0);
  242. }
  243. DeleteObject(rgn);
  244. }
  245. else
  246. {
  247. CRect rtDraw(PrevLeft,PrevTop,rtMenu.right,PrevTop + MenuItemHeight);
  248. CRTDraw::RTDrawBitmap(pDC,&rtDraw,CRTMenu::m_MenuBarBitmap[BMP_BACK],CRTMenu::m_MenuBarBitmapDrawMode[BMP_BACK]);
  249. }
  250. PrevTop = MenuTop;
  251. PrevLeft = rtMenu.left + rtMenuItem.Width();
  252. }
  253. else
  254. {
  255. PrevLeft += rtMenuItem.Width();
  256. }
  257. }
  259. if(!CRTMenu::m_bEnableSkin)
  260. {
  261. HRGN rgn = CreateRectRgn(rtWnd.left + PrevLeft,rtWnd.top + PrevTop,rtWnd.right - BorderWidth,rtWnd.top + PrevTop + MenuItemHeight);
  262. if(hrgn != NULL)
  263. {
  264. if(NULLREGION != CombineRgn(rgn,rgn,hrgn,RGN_AND))
  265. {
  266. CDialog::WindowProc(WM_NCPAINT,(WPARAM)rgn,0);
  267. }
  268. }
  269. else
  270. {
  271. CDialog::WindowProc(WM_NCPAINT,(WPARAM)rgn,0);
  272. }
  273. DeleteObject(rgn);
  274. }
  275. else
  276. {
  277. CRect rtDraw(PrevLeft,PrevTop,rtMenu.right,PrevTop + MenuItemHeight);
  278. CRTDraw::RTDrawBitmap(pDC,&rtDraw,CRTMenu::m_MenuBarBitmap[BMP_BACK],CRTMenu::m_MenuBarBitmapDrawMode[BMP_BACK]);
  279. }
  280. //画菜单上部线
  281. pDC->PatBlt(rtMenu.left,PrevTop + MenuItemHeight,rtMenu.Width(),1, PATCOPY);
  282. pDC->SelectObject(pOldBrush);
  283. return TRUE;
  284. }
  286. BOOL CRTDialog::SetMinimizeButtonBitmap(CBitmap *MinimizeButtonBitmap[],UINT DrawMode[])
  287. {
  288. for(int i = 0; i < 5; i ++)
  289. {
  290. m_MinimizeButtonBitmap[i] = MinimizeButtonBitmap[i];
  291. m_MinimizeButtonBitmapDrawMode[i] = DrawMode[i];
  292. }
  293. return TRUE;
  294. }
  296. BOOL CRTDialog::SetTitleBarBitmap(CBitmap *TitleBarBitmap[],UINT DrawMode[])
  297. {
  298. for(int i = 0; i < 5; i ++)
  299. {
  300. m_TitleBarBitmap[i] = TitleBarBitmap[i];
  301. m_TitleBarBitmapDrawMode[i] = DrawMode[i];
  302. }
  303. return TRUE;
  304. }
  306. BOOL CRTDialog::SetMenuBarBitmap(CBitmap* MenuBarBitmap[],UINT DrawMode[])
  307. {
  308. for(int i = 0; i < 5; i ++)
  309. {
  310. m_MenuBarBitmap[i] = MenuBarBitmap[i];
  311. m_MenuBarBitmapDrawMode[i] = DrawMode[i];
  312. }
  313. return TRUE;
  314. }
  316. BOOL CRTDialog::SetMaximizeButtonBitmap(CBitmap* MaximizeButtonBitmap[],UINT DrawMode[])
  317. {
  318. for(int i = 0; i < 5; i ++)
  319. {
  320. m_MaximizeButtonBitmap[i] =  MaximizeButtonBitmap[i];
  321. m_MinimizeButtonBitmapDrawMode[i] = DrawMode[i];
  322. }
  323. return TRUE;
  324. }
  326. BOOL CRTDialog::SetBorderColor(COLORREF ColorArray[])
  327. {
  328. for(int i = 0; i < 4 ; i++)
  329. m_BorderColor[i] = ColorArray[i];
  330. return TRUE;
  331. }
  333. BOOL CRTDialog::RTDrawTitleBar(CDC* pDC,BOOL bActive,HRGN hrgn)
  334. {
  335. //取得标题栏的位置
  336. DWORD style = GetStyle();
  337. if((style & WS_CAPTION) != WS_CAPTION)return TRUE;
  339. CRect rtWnd;
  340. GetWindowRect(&rtWnd);
  342. if(!m_bEnableTitleBar)
  343. {
  344. rtWnd.left = rtWnd.left + GetSystemMetrics(SM_CXDLGFRAME);
  345. rtWnd.top = rtWnd.top + GetSystemMetrics(SM_CYDLGFRAME);
  346. rtWnd.right = rtWnd.right - GetSystemMetrics(SM_CYDLGFRAME);
  347. rtWnd.bottom = rtWnd.top + GetSystemMetrics(SM_CYCAPTION);
  349. HRGN rgn = CreateRectRgn(rtWnd.left,rtWnd.top,rtWnd.right,rtWnd.bottom);
  350. if(hrgn != NULL)
  351. {
  352. if(NULLREGION != CombineRgn(rgn,rgn,hrgn,RGN_AND))
  353. {
  354. CDialog::WindowProc(WM_NCPAINT,(WPARAM)rgn,0);
  355. }
  356. }
  357. else
  358. {
  359. CDialog::WindowProc(WM_NCPAINT,(WPARAM)rgn,0);
  360. }
  362. DeleteObject(rgn);
  363. return TRUE;
  364. }
  366. CRect rtTitle;
  367. rtTitle.left = GetSystemMetrics(SM_CXDLGFRAME);
  368. rtTitle.top =  GetSystemMetrics(SM_CYDLGFRAME);
  369. rtTitle.right = rtWnd.Width() - GetSystemMetrics(SM_CYDLGFRAME);
  370. rtTitle.bottom = rtTitle.top + GetSystemMetrics(SM_CYCAPTION);
  372. CMemDC memDC(pDC,rtTitle);
  373. CBitmap*  BackBitmap;
  374. COLORREF TitleTextColor;
  375. UINT     DrawMode;
  377. if(bActive)
  378. {
  379. BackBitmap = m_TitleBarBitmap[BMP_ACTIVE];
  380. DrawMode = m_TitleBarBitmapDrawMode[BMP_ACTIVE];
  381. TitleTextColor = GetSysColor(COLOR_CAPTIONTEXT);
  382. }
  383. else
  384. {
  385. BackBitmap = m_TitleBarBitmap[BMP_INACTIVE];
  386. DrawMode = m_TitleBarBitmapDrawMode[BMP_INACTIVE];
  387. TitleTextColor = GetSysColor(COLOR_INACTIVECAPTIONTEXT);
  388. }
  390. if(BackBitmap == NULL)return FALSE;
  392. //用位图画标题栏
  393. CRTDraw::RTDrawBitmap(&memDC,&rtTitle,BackBitmap,DrawMode);
  395. //画标题栏图标
  396. HICON hIcon = GetIcon(FALSE);
  397. CRect rtTitleText;
  398. if(hIcon != NULL)
  399. {
  400. DrawIconEx(memDC.m_hDC,rtTitle.left+1,rtTitle.top+1,hIcon,rtTitle.Height() - 2,rtTitle.Height() - 2,0,NULL,DI_NORMAL);
  401. rtTitleText.SetRect(rtTitle.left + rtTitle.Height(),rtTitle.top,rtTitle.right - 60,rtTitle.bottom);
  402. }
  403. else
  404. {
  405. rtTitleText.SetRect(rtTitle.left + 1,rtTitle.top,rtTitle.right - 60,rtTitle.bottom);
  406. }
  408. //画标题栏文字
  409. CFont TitleFont;
  410. NONCLIENTMETRICS nif;
  411. nif.cbSize = sizeof(nif);
  412. SystemParametersInfo(SPI_GETNONCLIENTMETRICS,sizeof(NONCLIENTMETRICS),&nif,0);
  413. TitleFont.CreateFontIndirect(&nif.lfCaptionFont);
  414. CFont *pOldFont = memDC.SelectObject(&TitleFont);
  415. CString titleText;
  416. GetWindowText(titleText);
  418. int oldBkMode = memDC.SetBkMode(TRANSPARENT);
  419. int oldTextColor = memDC.SetTextColor(TitleTextColor);
  421. TEXTMETRIC Metrics;
  422. pDC->GetTextMetrics(&Metrics);
  423. rtTitleText.top = rtTitle.top + (rtTitle.Height() - Metrics.tmHeight)/2 + 1;
  425. memDC.DrawText(titleText,&rtTitleText,DT_LEFT | DT_SINGLELINE);
  426. memDC.SetBkMode(oldBkMode);
  427. memDC.SetTextColor(oldTextColor);
  428. memDC.SelectObject(&pOldFont);
  430. //画标题栏按扭
  431. RTDrawTitleBarButtons(&memDC);
  432. return TRUE;
  433. }
  435. LRESULT CRTDialog::OnRTNcPaint(WPARAM wParam, LPARAM lParam)
  436. {
  437. //绘制非客户区
  438. if(m_bEnableSkin == FALSE)
  439. {
  440. return CDialog::WindowProc(WM_NCPAINT,wParam,lParam);
  441. }
  443. CWindowDC dc(this);
  444. HRGN hrgn = NULL;
  445. CRect rtWnd;
  446. GetWindowRect(&rtWnd);
  447. if(wParam != 1)
  448. {
  449. hrgn = (HRGN)wParam;
  450. }
  452. if(hrgn != NULL)
  453. {
  454. ::SelectClipRgn(dc.m_hDC,hrgn);
  455. ::OffsetClipRgn(dc.m_hDC,0 - rtWnd.left,0 - rtWnd.top);
  456. }
  457. RTDrawFrameBorder(&dc,hrgn);
  458. RTDrawTitleBar(&dc,m_bActive,hrgn);
  459. RTDrawMenuBar(&dc,lParam);
  460. if(hrgn != NULL)
  461. {
  462. ::SelectClipRgn(dc.m_hDC,NULL);
  463. DeleteObject(hrgn);
  464. }
  465. return FALSE;
  466. }
  468. BOOL CRTDialog::EnableSkin(BOOL bEnable,BOOL bEnableBorder,BOOL bEnableBack,BOOL bEnableTitleBar)
  469. {
  470. m_bEnableSkin = bEnable;
  471. m_bEnableBack = bEnableBack;
  472. m_bEnableTitleBar = bEnableTitleBar;
  473. m_bEnableBorder = bEnableBorder;
  474. return bEnable;
  475. }
  477. LRESULT CRTDialog::OnRTNcActive(WPARAM wParam, LPARAM lParam)
  478. {
  479. if(!m_bEnableSkin)return CDialog::WindowProc(WM_NCACTIVATE,wParam,lParam);
  480. if(!m_bEnableTitleBar)return CDialog::WindowProc(WM_NCACTIVATE,wParam,lParam);
  482. CWindowDC dc(this);
  483. RTDrawTitleBar(&dc,m_bActive);
  484. return TRUE;
  485. }
  487. LRESULT CRTDialog::OnRTActive(WPARAM wParam,LPARAM lParam)
  488. {
  489. LRESULT result = CDialog::WindowProc(WM_ACTIVATE,wParam,lParam);
  490. if(!m_bEnableSkin)return result;
  491. if(!m_bEnableTitleBar)return result;
  493. CWindowDC dc(this);
  494. if(wParam == WA_INACTIVE)
  495. {
  496. m_bActive = FALSE;
  497. }
  498. else
  499. {
  500. m_bActive = TRUE;
  501. }
  503. OnRTNcPaint(1,0);
  504. return result;
  505. }
  507. LRESULT CRTDialog::OnRTNodify(WPARAM wParam, LPARAM lParam)
  508. {
  509. LRESULT result = CDialog::WindowProc(WM_NOTIFY,wParam,lParam);
  510. if(!m_bEnableSkin)return result;
  511. if(!m_bEnableTitleBar)return result;
  513. CWindowDC dc(this);
  514. RTDrawTitleBar(&dc,m_bActive);
  515. return result;
  516. }
  518. LRESULT CRTDialog::OnRTActiveApp(WPARAM wParam,LPARAM lParam)
  519. {
  520. if(!m_bEnableSkin)return CDialog::WindowProc(WM_ACTIVATEAPP,wParam,lParam);
  521. if(!m_bEnableTitleBar)return CDialog::WindowProc(WM_ACTIVATEAPP,wParam,lParam);
  523. LRESULT result = CDialog::WindowProc(WM_ACTIVATEAPP,wParam,lParam);
  524. m_bActive = (BOOL)wParam;
  525. return 0;
  526. }
  528. LRESULT CRTDialog::OnRTSetText(WPARAM wParam, LPARAM lParam)
  529. {
  530. LRESULT result = CDialog::WindowProc(WM_SETTEXT,wParam,lParam);
  532. if(!m_bEnableSkin)return result;
  533. if(!m_bEnableTitleBar)return result;
  535. CWindowDC dc(this);
  536. RTDrawTitleBar(&dc,m_bActive);
  537. return result;
  538. }
  540. BOOL CRTDialog::SetRestoreButtonBitmap(CBitmap* RestoreButtonBitmap[],UINT DrawMode[])
  541. {
  542. for(int i = 0; i < 5; i ++)
  543. {
  544. m_RestoreButtonBitmap[i] = RestoreButtonBitmap[i];
  545. m_RestoreButtonBitmapDrawMode[i] = DrawMode[i];
  546. }
  547. return TRUE;
  548. }
  549. BOOL CRTDialog::SetExitButtonBitmap(CBitmap* ExitButtonBitmap[],UINT DrawMode[])
  550. {
  551. for(int i = 0; i < 5; i ++)
  552. {
  553. m_ExitButtonBitmap[i] = ExitButtonBitmap[i];
  554. m_ExitButtonBitmapDrawMode[i] = DrawMode[i];
  555. }
  556. return TRUE;
  557. }
  560. BOOL CRTDialog::RTDrawTitleBarButtons(CDC* pDC)
  561. {
  562. //取得标题栏的位置
  563. CRect rtWnd;
  564. CRect rtTitle;
  565. GetWindowRect(&rtWnd);
  566. rtTitle.left = GetSystemMetrics(SM_CXDLGFRAME);
  567. rtTitle.top = GetSystemMetrics(SM_CYDLGFRAME);
  568. rtTitle.right = rtWnd.right - rtWnd.left - GetSystemMetrics(SM_CXDLGFRAME);
  569. rtTitle.bottom = rtTitle.top + GetSystemMetrics(SM_CYCAPTION);
  571. CRect rtButtons;
  573. //画标题栏按扭
  574. DWORD dwStyle = GetStyle();
  576. CBitmap* pCloseBox = NULL;
  577. CBitmap* pMaximizeBox = NULL;
  578. CBitmap* pMinimizeBox = NULL;
  580. if(TRUE)
  581. {
  582. if(m_ExitButtonState == StateNormal)
  583. {
  584. pCloseBox = m_ExitButtonBitmap[BMP_NORMAL];
  585. }
  586. else if(m_ExitButtonState == StateDown)
  587. {
  588. pCloseBox = m_ExitButtonBitmap[BMP_DOWN];
  589. }
  590. else if(m_ExitButtonState == StateFocus)
  591. {
  592. pCloseBox = m_ExitButtonBitmap[BMP_FOCUS];
  593. }
  594. }
  596. if(WS_MAXIMIZEBOX & dwStyle)
  597. {
  598. if(IsZoomed())
  599. {
  600. if(m_MaximizeButtonState == StateNormal)
  601. {
  602. pMaximizeBox = m_RestoreButtonBitmap[BMP_NORMAL];
  603. }
  604. else if(m_MaximizeButtonState == StateDown)
  605. {
  606. pMaximizeBox = m_RestoreButtonBitmap[BMP_DOWN];
  607. }
  608. else if(m_MaximizeButtonState == StateFocus)
  609. {
  610. pMaximizeBox = m_RestoreButtonBitmap[BMP_FOCUS];
  611. }
  612. }
  613. else
  614. {
  615. if(m_MaximizeButtonState == StateNormal)
  616. {
  617. pMaximizeBox = m_MaximizeButtonBitmap[BMP_NORMAL];
  618. }
  619. else if(m_MaximizeButtonState == StateDown)
  620. {
  621. pMaximizeBox = m_MaximizeButtonBitmap[BMP_DOWN];
  622. }
  623. else if(m_MaximizeButtonState == StateFocus)
  624. {
  625. pMaximizeBox = m_MaximizeButtonBitmap[BMP_FOCUS];
  626. }
  627. }
  628. }
  629. else if(WS_MINIMIZEBOX & dwStyle)
  630. {
  631. if(IsZoomed())
  632. {
  633. pMaximizeBox = m_RestoreButtonBitmap[BMP_DISABLE];
  634. }
  635. else
  636. {
  637. pMaximizeBox = m_MaximizeButtonBitmap[BMP_DISABLE];
  638. }
  639. }
  641. if(WS_MINIMIZEBOX & dwStyle)
  642. {
  643. if(m_MinimizeButtonState == StateNormal)
  644. {
  645. pMinimizeBox = m_MinimizeButtonBitmap[BMP_NORMAL];
  646. }
  647. else if(m_MinimizeButtonState == StateDown)
  648. {
  649. pMinimizeBox = m_MinimizeButtonBitmap[BMP_DOWN];
  650. }
  651. else if(m_MinimizeButtonState == StateFocus)
  652. {
  653. pMinimizeBox = m_MinimizeButtonBitmap[BMP_FOCUS];
  654. }
  655. }
  656. else if(WS_MAXIMIZEBOX & dwStyle)
  657. {
  658. pMinimizeBox = m_MinimizeButtonBitmap[BMP_DISABLE];
  659. }
  662. //重画关闭button
  663. if(dwStyle & WS_SYSMENU)
  664. {
  665. rtButtons.left = rtTitle.right - rtTitle.Height();
  666. rtButtons.top = rtTitle.top + 2;
  667. rtButtons.right = rtTitle.right - 2;
  668. rtButtons.bottom = rtTitle.bottom - 2;
  669. CRTDraw::RTDrawBitmap(pDC,&rtButtons,pCloseBox,CRTDraw::DrawModeAllStretch);
  670. }
  671. //重画最大化/恢复button
  672. if(dwStyle & WS_MAXIMIZEBOX || dwStyle & WS_MINIMIZEBOX)
  673. {
  674. rtButtons.right = rtButtons.left - 2;
  675. rtButtons.left = rtButtons.left - rtTitle.Height();
  676. CRTDraw::RTDrawBitmap(pDC,&rtButtons,pMaximizeBox,CRTDraw::DrawModeAllStretch);
  677. }
  678. //重画最小化button
  679. if(dwStyle & WS_MAXIMIZEBOX || dwStyle & WS_MINIMIZEBOX)
  680. {
  681. rtButtons.right = rtButtons.left;
  682. rtButtons.left = rtButtons.left - rtTitle.Height() + 2;
  683. CRTDraw::RTDrawBitmap(pDC,&rtButtons,pMinimizeBox,CRTDraw::DrawModeAllStretch);
  684. }
  685. return TRUE;
  686. }
  688. LRESULT CRTDialog::OnRTNcRButtonUp(WPARAM wParam,LPARAM lParam)
  689. {
  690. if(!m_bEnableSkin)return CDialog::WindowProc(WM_NCRBUTTONUP,wParam,lParam);
  691. if(!m_bEnableTitleBar)return CDialog::WindowProc(WM_NCRBUTTONUP,wParam,lParam);
  693. CWindowDC dc(this);
  694. RTDrawTitleBar(&dc,m_bActive);
  695. return CDialog::WindowProc(WM_NCRBUTTONUP,wParam,lParam);
  696. }
  698. LRESULT CRTDialog::OnRTSetIcon(WPARAM wParam, LPARAM lParam)
  699. {
  700. LRESULT result = CDialog::WindowProc(WM_SETICON,wParam,lParam);
  701. if(!m_bEnableSkin)return result;
  702. if(!m_bEnableTitleBar)return result;
  704. if(IsWindow(m_hWnd))
  705. {
  706. CWindowDC dc(this);
  707. RTDrawTitleBar(&dc,m_bActive);
  708. }
  709. return result;
  710. }
  712. LRESULT CRTDialog::OnRTNcMouseMove(WPARAM wParam,LPARAM lParam)
  713. {
  714. if(!m_bEnableSkin)return CDialog::WindowProc(WM_NCMOUSEMOVE,wParam,lParam);
  715. if(!m_bEnableTitleBar)return CDialog::WindowProc(WM_NCMOUSEMOVE,wParam,lParam);
  717. LRESULT result = 0;
  718. CWindowDC dc(this);
  719. switch(wParam)
  720. {
  721. case HTMAXBUTTON:
  722. if(m_NcMouseState == MouseStateNormal)
  723. {
  724. if(m_MaximizeButtonState != StateFocus)
  725. {
  726. m_MaximizeButtonState = StateFocus;
  727. m_MinimizeButtonState = StateNormal;
  728. m_ExitButtonState = StateNormal;
  729. RTDrawTitleBarButtons(&dc);
  730. }
  731. }
  732. else if(m_NcMouseState == MouseStateDown)
  733. {
  734. if(m_SelTitleButton == MaximizeButton)
  735. {
  736. if(m_MaximizeButtonState != StateDown)
  737. {
  738. m_MaximizeButtonState = StateDown;
  739. RTDrawTitleBarButtons(&dc);
  740. }
  741. }
  742. else if(m_SelTitleButton != NoneButton)
  743. {
  744. m_MinimizeButtonState = StateNormal;
  745. m_ExitButtonState = StateNormal;
  746. RTDrawTitleBarButtons(&dc);
  747. }
  748. }
  749. break;
  750. case HTMINBUTTON:
  751. if(m_NcMouseState == MouseStateNormal)
  752. {
  753. if(m_MinimizeButtonState != StateFocus)
  754. {
  755. m_MinimizeButtonState = StateFocus;
  756. m_MaximizeButtonState = StateNormal;
  757. m_ExitButtonState = StateNormal;
  758. RTDrawTitleBarButtons(&dc);
  759. }
  760. }
  761. else if(m_NcMouseState == MouseStateDown)
  762. {
  763. if(m_SelTitleButton == MinimizeButton)
  764. {
  765. if(m_MinimizeButtonState != StateDown)
  766. {
  767. m_MinimizeButtonState = StateDown;
  768. RTDrawTitleBarButtons(&dc);
  769. }
  770. }
  771. else if(m_SelTitleButton != NoneButton)
  772. {
  773. m_MaximizeButtonState = StateNormal;
  774. m_ExitButtonState = StateNormal;
  775. RTDrawTitleBarButtons(&dc);
  776. }
  777. }
  778. break;
  779. case HTCLOSE:
  780. if(m_NcMouseState == MouseStateNormal)
  781. {
  782. if(m_ExitButtonState != StateFocus)
  783. {
  784. m_ExitButtonState = StateFocus;
  785. m_MaximizeButtonState = StateNormal;
  786. m_MinimizeButtonState = StateNormal;
  787. RTDrawTitleBarButtons(&dc);
  788. }
  789. }
  790. else if(m_NcMouseState == MouseStateDown)
  791. {
  792. if(m_SelTitleButton == ExitButton)
  793. {
  794. if(m_ExitButtonState != StateDown)
  795. {
  796. m_ExitButtonState = StateDown;
  797. RTDrawTitleBarButtons(&dc);
  798. }
  799. }
  800. else if(m_SelTitleButton != NoneButton)
  801. {
  802. m_MaximizeButtonState = StateNormal;
  803. m_MinimizeButtonState = StateNormal;
  804. RTDrawTitleBarButtons(&dc);
  805. }
  806. }
  807. break;
  808. default:
  809. if(m_ExitButtonState != StateNormal || m_MinimizeButtonState != StateNormal || m_MaximizeButtonState != StateNormal)
  810. {
  811. m_MaximizeButtonState = StateNormal;
  812. m_MinimizeButtonState = StateNormal;
  813. m_ExitButtonState = StateNormal;
  814. RTDrawTitleBarButtons(&dc);
  815. }
  816. result = 0;//DefWindowProc(WM_NCMOUSEMOVE,wParam,lParam);
  817. break;
  818. }
  819. return result;
  820. }
  822. LRESULT CRTDialog::OnRTNcLMouseDown(WPARAM wParam,LPARAM lParam)
  823. {
  824. if(!m_bEnableSkin)return CDialog::WindowProc(WM_NCLBUTTONDOWN,wParam,lParam);
  825. if(!m_bEnableTitleBar)return CDialog::WindowProc(WM_NCLBUTTONDOWN,wParam,lParam);
  827. LRESULT result = 0;
  828. CWindowDC dc(this);
  829. switch(wParam)
  830. {
  831. case HTMAXBUTTON:
  832. m_NcMouseState = MouseStateDown;
  833. m_SelTitleButton = MaximizeButton;
  834. m_MaximizeButtonState = StateDown;
  835. RTDrawTitleBarButtons(&dc);
  836. SetCapture();
  837. break;
  838. case HTMINBUTTON:
  839. m_NcMouseState = MouseStateDown;
  840. m_SelTitleButton = MinimizeButton;
  841. m_MinimizeButtonState = StateDown;
  842. RTDrawTitleBarButtons(&dc);
  843. SetCapture();
  844. break;
  845. case HTCLOSE:
  846. m_NcMouseState = MouseStateDown;
  847. m_SelTitleButton = ExitButton;
  848. m_ExitButtonState = StateDown;
  849. RTDrawTitleBarButtons(&dc);
  850. SetCapture();
  851. break;
  852. default:
  853. result = CDialog::WindowProc(WM_NCLBUTTONDOWN,wParam,lParam);
  854. break;
  855. }
  857. RTDrawTitleBar(&dc,m_bActive);
  858. return result;
  859. }
  861. LRESULT CRTDialog::OnRTNcLMouseUp(WPARAM wParam,LPARAM lParam)
  862. {
  863. if(!m_bEnableSkin)return CDialog::WindowProc(WM_NCLBUTTONUP,wParam,lParam);
  864. if(!m_bEnableTitleBar)return CDialog::WindowProc(WM_NCLBUTTONUP,wParam,lParam);
  866. LRESULT result = 0;
  867. if(m_NcMouseState == MouseStateNormal)
  868. {
  869. return CDialog::WindowProc(WM_NCLBUTTONUP,wParam,lParam);
  870. }
  871. m_NcMouseState = MouseStateNormal;
  872. ReleaseCapture();
  874. if(wParam == HTMAXBUTTON)
  875. {
  876. if(m_SelTitleButton == MaximizeButton)
  877. {
  878. CWindowDC dc(this);
  879. m_SelTitleButton = NoneButton;
  880. m_MaximizeButtonState = StateNormal;
  881. RTDrawTitleBarButtons(&dc);
  882. if(IsZoomed())
  883. {
  884. SendMessage(WM_SYSCOMMAND, SC_RESTORE, lParam);
  885. }
  886. else
  887. {
  888. SendMessage(WM_SYSCOMMAND, SC_MAXIMIZE,lParam);
  889. }
  890. }
  891. }
  892. else if(wParam == HTMINBUTTON)
  893. {
  894. if(m_SelTitleButton == MinimizeButton)
  895. {
  896. CWindowDC dc(this);
  897. m_SelTitleButton = NoneButton;
  898. m_MinimizeButtonState = StateNormal;
  899. RTDrawTitleBarButtons(&dc);
  900. SendMessage(WM_SYSCOMMAND, SC_MINIMIZE,lParam);
  901. }
  902. }
  903. else if(wParam == HTCLOSE)
  904. {
  905. if(m_SelTitleButton == ExitButton)
  906. {
  907. CWindowDC dc(this);
  908. m_SelTitleButton = NoneButton;
  909. m_ExitButtonState = StateNormal;
  910. RTDrawTitleBarButtons(&dc);
  911. SendMessage(WM_CLOSE);
  912. }
  913. }
  914. else
  915. {
  916. m_MinimizeButtonState = StateNormal;
  917. m_MaximizeButtonState = StateNormal;
  918. m_ExitButtonState = StateNormal;
  919. result = CDialog::WindowProc(WM_NCLBUTTONUP,wParam,lParam);
  920. }
  921. return result;
  922. }
  924. LRESULT CRTDialog::OnRTMouseMove(WPARAM wParam, LPARAM lParam)
  925. {
  926. if(!m_bEnableSkin)return CDialog::WindowProc(WM_MOUSEMOVE,wParam,lParam);
  927. if(!m_bEnableTitleBar)return CDialog::WindowProc(WM_MOUSEMOVE,wParam,lParam);
  929. if(m_NcMouseState != MouseStateNormal)
  930. {
  931. CRect rtWnd;
  932. GetWindowRect(&rtWnd);
  933. CPoint point(lParam);
  934. ClientToScreen(&point);
  935. UINT hit = (UINT)CDialog::WindowProc(WM_NCHITTEST,wParam,MAKELPARAM(point.x,point.y));
  936. return OnRTNcMouseMove(hit,MAKELPARAM(point.x,point.y));
  937. }
  938. else
  939. {
  940. if(m_ExitButtonState != StateNormal || m_MinimizeButtonState != StateNormal || m_MaximizeButtonState != StateNormal)
  941. {
  942. CWindowDC dc(this);
  943. m_MaximizeButtonState = StateNormal;
  944. m_MinimizeButtonState = StateNormal;
  945. m_ExitButtonState = StateNormal;
  946. RTDrawTitleBarButtons(&dc);
  947. }
  948. }
  949. return CDialog::WindowProc(WM_MOUSEMOVE,wParam,lParam);
  950. }
  952. LRESULT CRTDialog::OnRTLButtonUp(WPARAM wParam, LPARAM lParam)
  953. {
  954. if(!m_bEnableSkin)return CDialog::WindowProc(WM_LBUTTONUP,wParam,lParam);
  955. if(!m_bEnableTitleBar)return CDialog::WindowProc(WM_LBUTTONUP,wParam,lParam);
  957. if(m_NcMouseState != MouseStateNormal)
  958. {
  959. CRect rtWnd;
  960. GetWindowRect(&rtWnd);
  961. CPoint point(lParam);
  962. ClientToScreen(&point);
  963. UINT hit = (UINT)CDialog::WindowProc(WM_NCHITTEST,wParam,MAKELPARAM(point.x,point.y));
  964. return OnRTNcLMouseUp(hit,MAKELPARAM(point.x,point.y));
  965. }
  966. return CDialog::WindowProc(WM_LBUTTONUP,wParam,lParam);
  967. }
  969. LRESULT CRTDialog::OnRTEraseBackGround(WPARAM wParam,LPARAM lParam)
  970. {
  971. if(!m_bEnableSkin || m_TitleBarBitmap[BMP_BACK] == NULL || !m_bEnableBack)
  972. return CDialog::WindowProc(WM_ERASEBKGND,wParam,lParam);
  974. CDC *pDC = CDC::FromHandle((HDC)wParam);
  975. CRect rtClient;
  976. GetClientRect(&rtClient);
  977. CRTDraw::RTDrawBitmap(pDC,&rtClient,m_TitleBarBitmap[BMP_BACK],m_TitleBarBitmapDrawMode[BMP_BACK]);
  978. return TRUE;
  979. }
  981. LRESULT CRTDialog::OnRTNcRButtonDown(WPARAM wParam,LPARAM lParam)
  982. {
  983. if(!m_bEnableSkin)return CDialog::WindowProc(WM_NCRBUTTONDOWN,wParam,lParam);
  984. if(!m_bEnableTitleBar)return CDialog::WindowProc(WM_NCRBUTTONDOWN,wParam,lParam);
  986. return 0;
  987. }
  989. LRESULT CRTDialog::OnRTSysCommand(WPARAM wParam,LPARAM lParam)
  990. {
  991. if(!m_bEnableSkin)return CDialog::WindowProc(WM_SYSCOMMAND,wParam,lParam);
  992. if(!m_bEnableTitleBar)return CDialog::WindowProc(WM_SYSCOMMAND,wParam,lParam);
  994. CWindowDC dc(this);
  995. RTDrawTitleBar(&dc,m_bActive);
  997. return CDialog::WindowProc(WM_SYSCOMMAND,wParam,lParam);
  998. }
  1000. LRESULT CRTDialog::OnRTSetCursor(WPARAM wParam,LPARAM lParam)
  1001. {
  1002. LRESULT rt = CDialog::WindowProc(WM_SETCURSOR,wParam,lParam); 
  1003. if(!m_bEnableSkin)return rt;
  1004. if(!m_bEnableTitleBar)return rt;
  1006. UINT nHitTest = LOWORD(lParam);
  1007. if(m_bEnableSkin)
  1008. {
  1009. CWindowDC dc(this);
  1010. switch(nHitTest)
  1011. {
  1012. case HTBORDER:
  1013. case HTLEFT:
  1014. case HTRIGHT:
  1015. case HTTOP:
  1016. case HTBOTTOM:
  1017. case HTBOTTOMLEFT:
  1018. case HTBOTTOMRIGHT:
  1019. case HTTOPLEFT:
  1020. case HTTOPRIGHT:
  1021. RTDrawTitleBar(&dc,m_bActive);
  1022. break;
  1023. default:
  1024. break;
  1025. }
  1027. }
  1029. return rt;
  1030. }
  1032. LRESULT CRTDialog::WindowProc(UINT message, WPARAM wParam, LPARAM lParam)
  1033. {
  1034. switch(message)
  1035. {
  1036. case WM_INITMENUPOPUP:
  1037. if(m_bEnableSkin && m_bEnableTitleBar)
  1038. {
  1039. CWindowDC dc(this);
  1040. RTDrawTitleBar(&dc,m_bActive);
  1041. }
  1042. break;
  1043. case WM_NCPAINT:
  1044. return OnRTNcPaint(wParam,lParam);
  1045. case WM_NCACTIVATE:
  1046. return OnRTNcActive(wParam,lParam);
  1047. case WM_ACTIVATE:
  1048. return OnRTActive(wParam,lParam);
  1049. case WM_ACTIVATEAPP:
  1050. return OnRTActiveApp(wParam,lParam);
  1051. case WM_NOTIFY:
  1052. return OnRTNodify(wParam,lParam);
  1053. case WM_SETTEXT:
  1054. return OnRTSetText(wParam,lParam);
  1055. case WM_SETICON:
  1056. return OnRTSetIcon(wParam,lParam);
  1057. case WM_NCMOUSEMOVE:
  1058. return OnRTNcMouseMove(wParam,lParam);
  1059. case WM_NCLBUTTONDOWN:
  1060. return OnRTNcLMouseDown(wParam,lParam);
  1061. case WM_NCLBUTTONUP:
  1062. OnRTNcLMouseUp(wParam,lParam);
  1063. case WM_LBUTTONUP:
  1064. return OnRTLButtonUp(wParam,lParam);
  1065. case WM_MOUSEMOVE:
  1066. return OnRTMouseMove(wParam,lParam);
  1067. case WM_ERASEBKGND:
  1068. return OnRTEraseBackGround(wParam,lParam);
  1069. case WM_NCRBUTTONUP:
  1070. return OnRTNcRButtonUp(wParam,lParam);
  1071. case WM_NCRBUTTONDOWN:
  1072. return OnRTNcRButtonDown(wParam,lParam);
  1073. case WM_SYSCOMMAND:
  1074. return OnRTSysCommand(wParam,lParam);
  1075. case WM_SETCURSOR:
  1076. return OnRTSetCursor(wParam,lParam);
  1077. default:
  1078. break;
  1079. }
  1080. return CDialog::WindowProc(message, wParam, lParam);
  1081. }