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

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

界面编程

开发平台：

Visual C++

RTFrameWnd.cpp：源码内容
  1. // RTFrameWnd.cpp : CMainFrame 类的实现
  4. #include "stdafx.h"
  5. #include "RTFrameWnd.h"
  6. #include "RTDraw.h"
  7. #ifdef _DEBUG
  8. #define new DEBUG_NEW
  9. #endif
  12. // CRTFrameWnd
  14. IMPLEMENT_DYNCREATE(CRTFrameWnd, CFrameWnd)
  15. IMPLEMENT_MENUXP(CRTFrameWnd,CFrameWnd)
  17. BEGIN_MESSAGE_MAP(CRTFrameWnd, CFrameWnd)
  18. ON_WM_CREATE()
  19. END_MESSAGE_MAP()
  21. static UINT indicators[] =
  22. {
  23. ID_SEPARATOR,           // 状态行指示器
  24. ID_INDICATOR_CAPS,
  25. ID_INDICATOR_NUM,
  26. ID_INDICATOR_SCRL,
  27. };
  30. // CRTFrameWnd 构造/销毁
  32. CRTFrameWnd::CRTFrameWnd()
  33. {
  34. m_bActive = FALSE;
  36. m_ExitButtonState = StateNormal;
  37. m_MinimizeButtonState = StateNormal;
  38. m_MaximizeButtonState = StateNormal;
  39. m_NcMouseState = MouseStateNormal;
  40. m_SelTitleButton = NoneButton;
  41. }
  43. CRTFrameWnd::~CRTFrameWnd()
  44. {
  46. }
  48. COLORREF CRTFrameWnd::m_BorderColor[4] = {0xAD9E9C,0xCEBEB5,0xCEBEB5,0xDED3CE};
  49. BOOL     CRTFrameWnd::m_bEnableSkin = FALSE;
  50. BOOL     CRTFrameWnd::m_bEnableBackAndBorder = FALSE;
  51. BOOL     CRTFrameWnd::m_bEnableTitleBar = FALSE;
  52. CBitmap* CRTFrameWnd::m_TitleBarBitmap[5] = {NULL,NULL,NULL,NULL,NULL};
  53. CBitmap* CRTFrameWnd::m_MenuBarBitmap[5] = {NULL,NULL,NULL,NULL,NULL};
  54. CBitmap* CRTFrameWnd::m_MaximizeButtonBitmap[5] = {NULL,NULL,NULL,NULL,NULL};
  55. CBitmap* CRTFrameWnd::m_MinimizeButtonBitmap[5] = {NULL,NULL,NULL,NULL,NULL};
  56. CBitmap* CRTFrameWnd::m_RestoreButtonBitmap[5] = {NULL,NULL,NULL,NULL,NULL};
  57. CBitmap* CRTFrameWnd::m_ExitButtonBitmap[5] = {NULL,NULL,NULL,NULL,NULL};
  59. UINT     CRTFrameWnd::m_TitleBarBitmapDrawMode[5] = {0,0,0,0,0};
  60. UINT     CRTFrameWnd::m_MenuBarBitmapDrawMode[5] = {0,0,0,0,0};
  61. UINT     CRTFrameWnd::m_MaximizeButtonBitmapDrawMode[5] = {0,0,0,0,0};
  62. UINT     CRTFrameWnd::m_MinimizeButtonBitmapDrawMode[5] = {0,0,0,0,0};
  63. UINT     CRTFrameWnd::m_ExitButtonBitmapDrawMode[5] = {0,0,0,0,0};
  64. UINT     CRTFrameWnd::m_RestoreButtonBitmapDrawMode[5] = {0,0,0,0,0};
  67. int CRTFrameWnd::OnCreate(LPCREATESTRUCT lpCreateStruct)
  68. {
  69. if (CFrameWnd::OnCreate(lpCreateStruct) == -1)
  70. return -1;
  72. return 0;
  73. }
  75. BOOL CRTFrameWnd::PreCreateWindow(CREATESTRUCT& cs)
  76. {
  77. if( !CFrameWnd::PreCreateWindow(cs) )
  78. return FALSE;
  79. return TRUE;
  80. }
  83. // CRTFrameWnd 诊断
  85. #ifdef _DEBUG
  86. void CRTFrameWnd::AssertValid() const
  87. {
  88. CFrameWnd::AssertValid();
  89. }
  91. void CRTFrameWnd::Dump(CDumpContext& dc) const
  92. {
  93. CFrameWnd::Dump(dc);
  94. }
  96. #endif //_DEBUG
  99. // CRTFrameWnd 消息处理程序
  100. BOOL CRTFrameWnd::RTDrawFrameBorder(CDC *pDC,HRGN hRgn)
  101. {
  102. //画框架
  103. CRect rtWnd;
  104. GetWindowRect(&rtWnd);
  106. int Frame_BorderWidth = GetSystemMetrics(SM_CXFRAME);
  107. int Frame_BorderHeight =GetSystemMetrics(SM_CYFRAME);
  109. if(!m_bEnableBackAndBorder)
  110. {
  111. HRGN rgn = NULL;
  113. //left border
  114. rgn = CreateRectRgn(rtWnd.left,rtWnd.top,rtWnd.left + Frame_BorderWidth,rtWnd.bottom);
  115. if(hRgn != NULL)
  116. {
  117. if(NULLREGION != CombineRgn(rgn,rgn,hRgn,RGN_AND))
  118. {
  119. CFrameWnd::WindowProc(WM_NCPAINT,(WPARAM)rgn,0);
  120. }
  121. }
  122. else
  123. {
  124. CFrameWnd::WindowProc(WM_NCPAINT,(WPARAM)rgn,0);
  125. }
  126. DeleteObject(rgn);
  128. //top border
  129. rgn = CreateRectRgn(rtWnd.left,rtWnd.top,rtWnd.right,rtWnd.top + Frame_BorderHeight);
  130. if(hRgn != NULL && NULLREGION != CombineRgn(rgn,rgn,hRgn,RGN_AND))
  131. {
  132. CFrameWnd::WindowProc(WM_NCPAINT,(WPARAM)rgn,0);
  133. }
  134. else
  135. {
  136. CFrameWnd::WindowProc(WM_NCPAINT,(WPARAM)rgn,0);
  137. }
  138. DeleteObject(rgn);
  140. //right border
  141. rgn = CreateRectRgn(rtWnd.right - Frame_BorderWidth,rtWnd.top,rtWnd.right,rtWnd.bottom);
  142. if(hRgn != NULL && NULLREGION != CombineRgn(rgn,rgn,hRgn,RGN_AND))
  143. {
  144. CFrameWnd::WindowProc(WM_NCPAINT,(WPARAM)rgn,0);
  145. }
  146. else
  147. {
  148. CFrameWnd::WindowProc(WM_NCPAINT,(WPARAM)rgn,0);
  149. }
  150. DeleteObject(rgn);
  152. //bottom
  153. rgn = CreateRectRgn(rtWnd.left,rtWnd.bottom - Frame_BorderHeight,rtWnd.right,rtWnd.bottom);
  154. if(hRgn != NULL && NULLREGION != CombineRgn(rgn,rgn,hRgn,RGN_AND))
  155. {
  156. CFrameWnd::WindowProc(WM_NCPAINT,(WPARAM)rgn,0);
  157. }
  158. else
  159. {
  160. CFrameWnd::WindowProc(WM_NCPAINT,(WPARAM)rgn,0);
  161. }
  162. DeleteObject(rgn);
  163. return TRUE;
  164. }
  166. CRect rtBorder;
  167. rtBorder.SetRect(0,0,rtWnd.Width(),rtWnd.Height());
  168. //画立体边框
  170. for(int i = 0; i < Frame_BorderWidth ; i ++)
  171. {
  172. if(i < 4)
  173. {
  174. pDC->Draw3dRect(i,i,rtWnd.Width() - 2*i,rtWnd.Height() - 2*i,m_BorderColor[i],m_BorderColor[i]);
  175. }
  176. else
  177. {
  178. pDC->Draw3dRect(i,i,rtWnd.Width() - 2*i,rtWnd.Height() - 2*i,m_BorderColor[3],m_BorderColor[3]);
  179. }
  180. }
  182. return TRUE;
  183. }
  186. BOOL CRTFrameWnd::RTDrawMenuBar(CDC *pDC,LPARAM lParam,HRGN hrgn)
  187. {
  188. CMenu *pMenu = GetMenu();
  189. if(pMenu == NULL)return TRUE;
  191. CRect rtMenu;
  192. CRect rtWnd;
  194. GetWindowRect(&rtWnd);
  195. rtMenu.left = GetSystemMetrics(SM_CXFRAME);
  196. rtMenu.top = GetSystemMetrics(SM_CYSIZE) + GetSystemMetrics(SM_CXFRAME) + 1;
  197. rtMenu.right = rtWnd.Width() - GetSystemMetrics(SM_CXFRAME);
  198. rtMenu.bottom = rtMenu.top +  GetSystemMetrics(SM_CYMENU);
  200. UINT ItemCount = pMenu->GetMenuItemCount();
  202. int PrevTop = rtMenu.top;
  203. int PrevLeft = rtMenu.left;
  204. int MenuItemHeight = GetSystemMetrics(SM_CYMENU);
  205. CRect rtMenuItem;
  207. //画菜单上部线
  208. CBrush brMenu(GetSysColor(COLOR_MENU));
  209. CBrush* pOldBrush = pDC->SelectObject(&brMenu);
  210. pDC->PatBlt(rtMenu.left,rtMenu.top - 1,rtMenu.Width(),1, PATCOPY);
  212. for(UINT items = 0; items < ItemCount; items++)
  213. {
  214. GetMenuItemRect(m_hWnd,pMenu->m_hMenu,items,&rtMenuItem);
  216. //画系统菜单
  217. HRGN rgn = CreateRectRgn(rtMenuItem.left,rtMenuItem.top,rtMenuItem.right,rtMenuItem.bottom);
  218. if(hrgn != NULL)
  219. {
  220. if(NULLREGION != CombineRgn(rgn,rgn,hrgn,RGN_AND))
  221. {
  222. CFrameWnd::WindowProc(WM_NCPAINT,(WPARAM)rgn,0);
  223. }
  224. }
  225. else
  226. {
  227. CFrameWnd::WindowProc(WM_NCPAINT,(WPARAM)rgn,0);
  228. }
  229. DeleteObject(rgn);
  231. int MenuTop = rtMenuItem.top - rtWnd.top;
  232. MenuItemHeight = rtMenuItem.Height();
  233. if(MenuTop != PrevTop)
  234. {
  235. if(!CRTMenu::m_bEnableSkin)
  236. {
  237. rgn = CreateRectRgn(rtWnd.left + PrevLeft,rtWnd.top + PrevTop,rtWnd.right - GetSystemMetrics(SM_CXFRAME),rtWnd.top + PrevTop + MenuItemHeight);
  238. if(hrgn != NULL)
  239. {
  240. if(NULLREGION != CombineRgn(rgn,rgn,hrgn,RGN_AND))
  241. {
  242. CFrameWnd::WindowProc(WM_NCPAINT,(WPARAM)rgn,0);
  243. }
  244. }
  245. else
  246. {
  247. CFrameWnd::WindowProc(WM_NCPAINT,(WPARAM)rgn,0);
  248. }
  249. DeleteObject(rgn);
  250. }
  251. else
  252. {
  253. CRect rtDraw(PrevLeft,PrevTop,rtMenu.right,PrevTop + MenuItemHeight);
  254. CRTDraw::RTDrawBitmap(pDC,&rtDraw,CRTMenu::m_MenuBarBitmap[BMP_BACK],CRTMenu::m_MenuBarBitmapDrawMode[BMP_BACK]);
  255. }
  256. PrevTop = MenuTop;
  257. PrevLeft = rtMenu.left + rtMenuItem.Width();
  258. }
  259. else
  260. {
  261. PrevLeft += rtMenuItem.Width();
  262. }
  263. }
  265. if(!CRTMenu::m_bEnableSkin)
  266. {
  267. HRGN rgn = CreateRectRgn(rtWnd.left + PrevLeft,rtWnd.top + PrevTop,rtWnd.right - GetSystemMetrics(SM_CXFRAME),rtWnd.top + PrevTop + MenuItemHeight);
  268. if(hrgn != NULL)
  269. {
  270. if(NULLREGION != CombineRgn(rgn,rgn,hrgn,RGN_AND))
  271. {
  272. CFrameWnd::WindowProc(WM_NCPAINT,(WPARAM)rgn,0);
  273. }
  274. }
  275. else
  276. {
  277. CFrameWnd::WindowProc(WM_NCPAINT,(WPARAM)rgn,0);
  278. }
  279. DeleteObject(rgn);
  280. }
  281. else
  282. {
  283. CRect rtDraw(PrevLeft,PrevTop,rtMenu.right,PrevTop + MenuItemHeight);
  284. CRTDraw::RTDrawBitmap(pDC,&rtDraw,CRTMenu::m_MenuBarBitmap[BMP_BACK],CRTMenu::m_MenuBarBitmapDrawMode[BMP_BACK]);
  285. }
  286. //画菜单上部线
  287. pDC->PatBlt(rtMenu.left,PrevTop + MenuItemHeight,rtMenu.Width(),1, PATCOPY);
  288. pDC->SelectObject(pOldBrush);
  289. return TRUE;
  290. }
  292. BOOL CRTFrameWnd::SetMinimizeButtonBitmap(CBitmap *MinimizeButtonBitmap[],UINT DrawMode[])
  293. {
  294. for(int i = 0; i < 5; i ++)
  295. {
  296. m_MinimizeButtonBitmap[i] = MinimizeButtonBitmap[i];
  297. m_MinimizeButtonBitmapDrawMode[i] = DrawMode[i];
  298. }
  299. return TRUE;
  300. }
  302. BOOL CRTFrameWnd::SetTitleBarBitmap(CBitmap *TitleBarBitmap[],UINT DrawMode[])
  303. {
  304. for(int i = 0; i < 5; i ++)
  305. {
  306. m_TitleBarBitmap[i] = TitleBarBitmap[i];
  307. m_TitleBarBitmapDrawMode[i] = DrawMode[i];
  308. }
  309. return TRUE;
  310. }
  312. BOOL CRTFrameWnd::SetMenuBarBitmap(CBitmap* MenuBarBitmap[],UINT DrawMode[])
  313. {
  314. for(int i = 0; i < 5; i ++)
  315. {
  316. m_MenuBarBitmap[i] = MenuBarBitmap[i];
  317. m_MenuBarBitmapDrawMode[i] = DrawMode[i];
  318. }
  319. return TRUE;
  320. }
  322. BOOL CRTFrameWnd::SetMaximizeButtonBitmap(CBitmap* MaximizeButtonBitmap[],UINT DrawMode[])
  323. {
  324. for(int i = 0; i < 5; i ++)
  325. {
  326. m_MaximizeButtonBitmap[i] =  MaximizeButtonBitmap[i];
  327. m_MinimizeButtonBitmapDrawMode[i] = DrawMode[i];
  328. }
  329. return TRUE;
  330. }
  332. BOOL CRTFrameWnd::SetBorderColor(COLORREF ColorArray[])
  333. {
  334. for(int i = 0; i < 5 ; i++)
  335. m_BorderColor[i] = ColorArray[i];
  336. return TRUE;
  337. }
  339. BOOL CRTFrameWnd::RTDrawTitleBar(CDC* pDC,BOOL bActive,HRGN hrgn)
  340. {
  341. //取得标题栏的位置
  342. DWORD style = GetStyle();
  343. if((style & WS_CAPTION) != WS_CAPTION)return TRUE;
  345. CRect rtWnd;
  346. GetWindowRect(&rtWnd);
  348. if(!m_bEnableTitleBar)
  349. {
  350. rtWnd.left = rtWnd.left + GetSystemMetrics(SM_CXFRAME);
  351. rtWnd.top = rtWnd.top + GetSystemMetrics(SM_CYFRAME);
  352. rtWnd.right = rtWnd.right - GetSystemMetrics(SM_CXFRAME);
  353. rtWnd.bottom = rtWnd.top + GetSystemMetrics(SM_CYSIZE);
  355. HRGN rgn = CreateRectRgn(rtWnd.left,rtWnd.top,rtWnd.right,rtWnd.bottom);
  356. if(hrgn != NULL)
  357. {
  358. if(NULLREGION != CombineRgn(rgn,rgn,hrgn,RGN_AND))
  359. {
  360. CFrameWnd::WindowProc(WM_NCPAINT,(WPARAM)rgn,0);
  361. }
  362. }
  363. else
  364. {
  365. CFrameWnd::WindowProc(WM_NCPAINT,(WPARAM)rgn,0);
  366. }
  368. DeleteObject(rgn);
  369. return TRUE;
  370. }
  372. CRect rtTitle;
  373. rtTitle.left = GetSystemMetrics(SM_CXFRAME);
  374. rtTitle.top = GetSystemMetrics(SM_CYFRAME);
  375. rtTitle.right = rtWnd.Width() - GetSystemMetrics(SM_CXFRAME);
  376. rtTitle.bottom = rtTitle.top + GetSystemMetrics(SM_CYSIZE);
  378. CMemDC memDC(pDC,rtTitle);
  379. CBitmap*  BackBitmap;
  380. COLORREF TitleTextColor;
  381. UINT     DrawMode;
  383. if(bActive)
  384. {
  385. BackBitmap = m_TitleBarBitmap[BMP_ACTIVE];
  386. DrawMode = m_TitleBarBitmapDrawMode[BMP_ACTIVE];
  387. TitleTextColor = GetSysColor(COLOR_CAPTIONTEXT);
  388. }
  389. else
  390. {
  391. BackBitmap = m_TitleBarBitmap[BMP_INACTIVE];
  392. DrawMode = m_TitleBarBitmapDrawMode[BMP_INACTIVE];
  393. TitleTextColor = GetSysColor(COLOR_INACTIVECAPTIONTEXT);
  394. }
  396. if(BackBitmap == NULL)return FALSE;
  398. //用位图画标题栏
  399. CRTDraw::RTDrawBitmap(&memDC,&rtTitle,BackBitmap,DrawMode);
  401. //画标题栏图标
  402. HICON hIcon = GetIcon(FALSE);
  403. CRect rtTitleText;
  404. if(hIcon != NULL)
  405. {
  406. DrawIconEx(memDC.m_hDC,rtTitle.left+1,rtTitle.top+1,hIcon,rtTitle.Height() - 2,rtTitle.Height() - 2,0,NULL,DI_NORMAL);
  407. rtTitleText.SetRect(rtTitle.left + rtTitle.Height(),rtTitle.top,rtTitle.right - 60,rtTitle.bottom);
  408. }
  409. else
  410. {
  411. rtTitleText.SetRect(rtTitle.left + 1,rtTitle.top,rtTitle.right - 60,rtTitle.bottom);
  412. }
  414. //画标题栏文字
  415. CFont TitleFont;
  416. NONCLIENTMETRICS nif;
  417. nif.cbSize = sizeof(nif);
  418. SystemParametersInfo(SPI_GETNONCLIENTMETRICS,sizeof(NONCLIENTMETRICS),&nif,0);
  419. TitleFont.CreateFontIndirect(&nif.lfCaptionFont);
  420. CFont *pOldFont = memDC.SelectObject(&TitleFont);
  421. CString titleText = GetTitle();
  423. int oldBkMode = memDC.SetBkMode(TRANSPARENT);
  424. int oldTextColor = memDC.SetTextColor(TitleTextColor);
  426. TEXTMETRIC Metrics;
  427. pDC->GetTextMetrics(&Metrics);
  428. rtTitleText.top = rtTitle.top + (rtTitle.Height() - Metrics.tmHeight)/2 + 1;
  430. memDC.DrawText(titleText,&rtTitleText,DT_LEFT | DT_SINGLELINE);
  431. memDC.SetBkMode(oldBkMode);
  432. memDC.SetTextColor(oldTextColor);
  433. memDC.SelectObject(&pOldFont);
  435. //画标题栏按扭
  436. RTDrawTitleBarButtons(&memDC);
  437. return TRUE;
  438. }
  440. LRESULT CRTFrameWnd::OnRTNcPaint(WPARAM wParam, LPARAM lParam)
  441. {
  442. //绘制非客户区
  443. if(!m_bEnableSkin)return CFrameWnd::WindowProc(WM_NCPAINT,wParam,lParam);
  446. CWindowDC dc(this);
  447. HRGN hrgn = NULL;
  448. CRect rtWnd;
  449. GetWindowRect(&rtWnd);
  450. if(wParam != 1)
  451. {
  452. hrgn = (HRGN)wParam;
  453. }
  455. if(hrgn != NULL)
  456. {
  457. ::SelectClipRgn(dc.m_hDC,hrgn);
  458. ::OffsetClipRgn(dc.m_hDC,0 - rtWnd.left,0 - rtWnd.top);
  459. }
  460. RTDrawFrameBorder(&dc,hrgn);
  461. RTDrawTitleBar(&dc,m_bActive,hrgn);
  462. RTDrawMenuBar(&dc,lParam);
  463. if(hrgn != NULL)
  464. {
  465. ::SelectClipRgn(dc.m_hDC,NULL);
  466. DeleteObject(hrgn);
  467. }
  468. return FALSE;
  469. }
  471. BOOL CRTFrameWnd::EnableSkin(BOOL bEnable,BOOL bEnablBackAndBorder,BOOL bEnableTitleBar)
  472. {
  473. m_bEnableSkin = bEnable;
  474. m_bEnableBackAndBorder = bEnablBackAndBorder;
  475. m_bEnableTitleBar = bEnableTitleBar;
  476. return bEnable;
  477. }
  479. LRESULT CRTFrameWnd::OnRTNcActive(WPARAM wParam, LPARAM lParam)
  480. {
  481. return CFrameWnd::WindowProc(WM_NCACTIVATE,wParam,lParam);
  482. }
  484. LRESULT CRTFrameWnd::OnRTActive(WPARAM wParam,LPARAM lParam)
  485. {
  486. LRESULT result = CFrameWnd::WindowProc(WM_ACTIVATE,wParam,lParam);
  487. if(!m_bEnableSkin)return result;
  488. if(!m_bEnableTitleBar)return result;
  490. if(!IsWindow(m_hWnd))return result;
  491. CWindowDC dc(this);
  492. if(wParam == WA_INACTIVE)
  493. {
  494. m_bActive = FALSE;
  495. }
  496. else
  497. {
  498. m_bActive = TRUE;
  499. }
  501. OnRTNcPaint(1,0);
  502. return result;
  503. }
  505. LRESULT CRTFrameWnd::OnRTNodify(WPARAM wParam, LPARAM lParam)
  506. {
  507. LRESULT result = CFrameWnd::WindowProc(WM_NOTIFY,wParam,lParam);
  508. if(!m_bEnableSkin)return result;
  509. if(!m_bEnableTitleBar)return result;
  511. CWindowDC dc(this);
  512. RTDrawTitleBar(&dc,m_bActive);
  513. return 0;
  514. }
  516. LRESULT CRTFrameWnd::OnRTActiveApp(WPARAM wParam,LPARAM lParam)
  517. {
  518. LRESULT result = CFrameWnd::WindowProc(WM_ACTIVATEAPP,wParam,lParam);
  519. if(!m_bEnableSkin)return result;
  520. if(!m_bEnableTitleBar)return result;
  522. m_bActive = (BOOL)wParam;
  523. return 0;
  524. }
  526. LRESULT CRTFrameWnd::OnRTSetText(WPARAM wParam, LPARAM lParam)
  527. {
  528. LRESULT result = CFrameWnd::WindowProc(WM_SETTEXT,wParam,lParam);
  530. if(!m_bEnableSkin)return result;
  531. if(!m_bEnableTitleBar)return result;
  533. CWindowDC dc(this);
  534. RTDrawTitleBar(&dc,m_bActive);
  535. return result;
  536. }
  538. BOOL CRTFrameWnd::SetRestoreButtonBitmap(CBitmap* RestoreButtonBitmap[],UINT DrawMode[])
  539. {
  540. for(int i = 0; i < 5; i ++)
  541. {
  542. m_RestoreButtonBitmap[i] = RestoreButtonBitmap[i];
  543. m_RestoreButtonBitmapDrawMode[i] = DrawMode[i];
  544. }
  545. return TRUE;
  546. }
  547. BOOL CRTFrameWnd::SetExitButtonBitmap(CBitmap* ExitButtonBitmap[],UINT DrawMode[])
  548. {
  549. for(int i = 0; i < 5; i ++)
  550. {
  551. m_ExitButtonBitmap[i] = ExitButtonBitmap[i];
  552. m_ExitButtonBitmapDrawMode[i] = DrawMode[i];
  553. }
  554. return TRUE;
  555. }
  558. BOOL CRTFrameWnd::RTDrawTitleBarButtons(CDC* pDC)
  559. {
  560. //取得标题栏的位置
  561. CRect rtWnd;
  562. CRect rtTitle;
  563. GetWindowRect(&rtWnd);
  564. rtTitle.left = GetSystemMetrics(SM_CXFRAME);
  565. rtTitle.top = GetSystemMetrics(SM_CYFRAME);
  566. rtTitle.right = rtWnd.right - rtWnd.left - GetSystemMetrics(SM_CXFRAME);
  567. rtTitle.bottom = rtTitle.top + GetSystemMetrics(SM_CYSIZE);
  569. CRect rtButtons;
  571. //画标题栏按扭
  572. DWORD dwStyle = GetStyle();
  574. CBitmap* pCloseBox = NULL;
  575. CBitmap* pMaximizeBox = NULL;
  576. CBitmap* pMinimizeBox = NULL;
  578. if(TRUE)
  579. {
  580. if(m_ExitButtonState == StateNormal)
  581. {
  582. pCloseBox = m_ExitButtonBitmap[BMP_NORMAL];
  583. }
  584. else if(m_ExitButtonState == StateDown)
  585. {
  586. pCloseBox = m_ExitButtonBitmap[BMP_DOWN];
  587. }
  588. else if(m_ExitButtonState == StateFocus)
  589. {
  590. pCloseBox = m_ExitButtonBitmap[BMP_FOCUS];
  591. }
  592. }
  594. if(WS_MAXIMIZEBOX & dwStyle)
  595. {
  596. if(IsZoomed())
  597. {
  598. if(m_MaximizeButtonState == StateNormal)
  599. {
  600. pMaximizeBox = m_RestoreButtonBitmap[BMP_NORMAL];
  601. }
  602. else if(m_MaximizeButtonState == StateDown)
  603. {
  604. pMaximizeBox = m_RestoreButtonBitmap[BMP_DOWN];
  605. }
  606. else if(m_MaximizeButtonState == StateFocus)
  607. {
  608. pMaximizeBox = m_RestoreButtonBitmap[BMP_FOCUS];
  609. }
  610. }
  611. else
  612. {
  613. if(m_MaximizeButtonState == StateNormal)
  614. {
  615. pMaximizeBox = m_MaximizeButtonBitmap[BMP_NORMAL];
  616. }
  617. else if(m_MaximizeButtonState == StateDown)
  618. {
  619. pMaximizeBox = m_MaximizeButtonBitmap[BMP_DOWN];
  620. }
  621. else if(m_MaximizeButtonState == StateFocus)
  622. {
  623. pMaximizeBox = m_MaximizeButtonBitmap[BMP_FOCUS];
  624. }
  625. }
  626. }
  627. else if(WS_MINIMIZEBOX & dwStyle)
  628. {
  629. if(IsZoomed())
  630. {
  631. pMaximizeBox = m_RestoreButtonBitmap[BMP_DISABLE];
  632. }
  633. else
  634. {
  635. pMaximizeBox = m_MaximizeButtonBitmap[BMP_DISABLE];
  636. }
  637. }
  639. if(WS_MINIMIZEBOX & dwStyle)
  640. {
  641. if(m_MinimizeButtonState == StateNormal)
  642. {
  643. pMinimizeBox = m_MinimizeButtonBitmap[BMP_NORMAL];
  644. }
  645. else if(m_MinimizeButtonState == StateDown)
  646. {
  647. pMinimizeBox = m_MinimizeButtonBitmap[BMP_DOWN];
  648. }
  649. else if(m_MinimizeButtonState == StateFocus)
  650. {
  651. pMinimizeBox = m_MinimizeButtonBitmap[BMP_FOCUS];
  652. }
  653. }
  654. else if(WS_MAXIMIZEBOX & dwStyle)
  655. {
  656. pMinimizeBox = m_MinimizeButtonBitmap[BMP_DISABLE];
  657. }
  659. //重画关闭button
  660. if(dwStyle & WS_SYSMENU)
  661. {
  662. rtButtons.left = rtTitle.right - rtTitle.Height();
  663. rtButtons.top = rtTitle.top + 2;
  664. rtButtons.right = rtTitle.right - 2;
  665. rtButtons.bottom = rtTitle.bottom - 2;
  666. CRTDraw::RTDrawBitmap(pDC,&rtButtons,pCloseBox,CRTDraw::DrawModeAllStretch);
  667. }
  668. //重画最大化/恢复button
  669. if(dwStyle & WS_MAXIMIZEBOX || dwStyle & WS_MINIMIZEBOX)
  670. {
  671. rtButtons.right = rtButtons.left - 2;
  672. rtButtons.left = rtButtons.left - rtTitle.Height();
  673. CRTDraw::RTDrawBitmap(pDC,&rtButtons,pMaximizeBox,CRTDraw::DrawModeAllStretch);
  674. }
  675. //重画最小化button
  676. if(dwStyle & WS_MAXIMIZEBOX || dwStyle & WS_MINIMIZEBOX)
  677. {
  678. rtButtons.right = rtButtons.left;
  679. rtButtons.left = rtButtons.left - rtTitle.Height() + 2;
  680. CRTDraw::RTDrawBitmap(pDC,&rtButtons,pMinimizeBox,CRTDraw::DrawModeAllStretch);
  681. }
  682. return TRUE;
  683. }
  686. LRESULT CRTFrameWnd::OnRTSetIcon(WPARAM wParam, LPARAM lParam)
  687. {
  688. LRESULT result = CFrameWnd::WindowProc(WM_SETICON,wParam,lParam);
  690. if(!m_bEnableSkin)return result;
  691. if(!m_bEnableTitleBar)return result;
  693. if(IsWindow(m_hWnd))
  694. {
  695. CWindowDC dc(this);
  696. RTDrawTitleBar(&dc,m_bActive);
  697. }
  698. return result;
  699. }
  701. LRESULT CRTFrameWnd::OnRTNcMouseMove(WPARAM wParam,LPARAM lParam)
  702. {
  703. if(!m_bEnableSkin)return CFrameWnd::WindowProc(WM_NCMOUSEMOVE,wParam,lParam);
  704. if(!m_bEnableTitleBar)return CFrameWnd::WindowProc(WM_NCMOUSEMOVE,wParam,lParam);
  706. LRESULT result = 0;
  707. CWindowDC dc(this);
  708. switch(wParam)
  709. {
  710. case HTMAXBUTTON:
  711. if(m_NcMouseState == MouseStateNormal)
  712. {
  713. if(m_MaximizeButtonState != StateFocus)
  714. {
  715. m_MaximizeButtonState = StateFocus;
  716. m_MinimizeButtonState = StateNormal;
  717. m_ExitButtonState = StateNormal;
  718. RTDrawTitleBarButtons(&dc);
  719. }
  720. }
  721. else if(m_NcMouseState == MouseStateDown)
  722. {
  723. if(m_SelTitleButton == MaximizeButton)
  724. {
  725. if(m_MaximizeButtonState != StateDown)
  726. {
  727. m_MaximizeButtonState = StateDown;
  728. RTDrawTitleBarButtons(&dc);
  729. }
  730. }
  731. else if(m_SelTitleButton != NoneButton)
  732. {
  733. m_MinimizeButtonState = StateNormal;
  734. m_ExitButtonState = StateNormal;
  735. RTDrawTitleBarButtons(&dc);
  736. }
  737. }
  738. break;
  739. case HTMINBUTTON:
  740. if(m_NcMouseState == MouseStateNormal)
  741. {
  742. if(m_MinimizeButtonState != StateFocus)
  743. {
  744. m_MinimizeButtonState = StateFocus;
  745. m_MaximizeButtonState = StateNormal;
  746. m_ExitButtonState = StateNormal;
  747. RTDrawTitleBarButtons(&dc);
  748. }
  749. }
  750. else if(m_NcMouseState == MouseStateDown)
  751. {
  752. if(m_SelTitleButton == MinimizeButton)
  753. {
  754. if(m_MinimizeButtonState != StateDown)
  755. {
  756. m_MinimizeButtonState = StateDown;
  757. RTDrawTitleBarButtons(&dc);
  758. }
  759. }
  760. else if(m_SelTitleButton != NoneButton)
  761. {
  762. m_MaximizeButtonState = StateNormal;
  763. m_ExitButtonState = StateNormal;
  764. RTDrawTitleBarButtons(&dc);
  765. }
  766. }
  767. break;
  768. case HTCLOSE:
  769. if(m_NcMouseState == MouseStateNormal)
  770. {
  771. if(m_ExitButtonState != StateFocus)
  772. {
  773. m_ExitButtonState = StateFocus;
  774. m_MaximizeButtonState = StateNormal;
  775. m_MinimizeButtonState = StateNormal;
  776. RTDrawTitleBarButtons(&dc);
  777. }
  778. }
  779. else if(m_NcMouseState == MouseStateDown)
  780. {
  781. if(m_SelTitleButton == ExitButton)
  782. {
  783. if(m_ExitButtonState != StateDown)
  784. {
  785. m_ExitButtonState = StateDown;
  786. RTDrawTitleBarButtons(&dc);
  787. }
  788. }
  789. else if(m_SelTitleButton != NoneButton)
  790. {
  791. m_MaximizeButtonState = StateNormal;
  792. m_MinimizeButtonState = StateNormal;
  793. RTDrawTitleBarButtons(&dc);
  794. }
  795. }
  796. break;
  797. default:
  798. if(m_ExitButtonState != StateNormal || m_MinimizeButtonState != StateNormal || m_MaximizeButtonState != StateNormal)
  799. {
  800. m_MaximizeButtonState = StateNormal;
  801. m_MinimizeButtonState = StateNormal;
  802. m_ExitButtonState = StateNormal;
  803. RTDrawTitleBarButtons(&dc);
  804. }
  805. result = 0;//CFrameWnd::WindowProc(WM_NCMOUSEMOVE,wParam,lParam);
  806. break;
  807. }
  808. return result;
  809. }
  811. LRESULT CRTFrameWnd::OnRTNcLMouseDown(WPARAM wParam,LPARAM lParam)
  812. {
  813. if(!m_bEnableSkin)return CFrameWnd::WindowProc(WM_NCLBUTTONDOWN,wParam,lParam);
  814. if(!m_bEnableTitleBar)return CFrameWnd::WindowProc(WM_NCLBUTTONDOWN,wParam,lParam);
  816. LRESULT result = 0;
  817. CWindowDC dc(this);
  818. switch(wParam)
  819. {
  820. case HTMAXBUTTON:
  821. m_NcMouseState = MouseStateDown;
  822. m_SelTitleButton = MaximizeButton;
  823. m_MaximizeButtonState = StateDown;
  824. RTDrawTitleBarButtons(&dc);
  825. SetCapture();
  826. break;
  827. case HTMINBUTTON:
  828. m_NcMouseState = MouseStateDown;
  829. m_SelTitleButton = MinimizeButton;
  830. m_MinimizeButtonState = StateDown;
  831. RTDrawTitleBarButtons(&dc);
  832. SetCapture();
  833. break;
  834. case HTCLOSE:
  835. m_NcMouseState = MouseStateDown;
  836. m_SelTitleButton = ExitButton;
  837. m_ExitButtonState = StateDown;
  838. RTDrawTitleBarButtons(&dc);
  839. SetCapture();
  840. break;
  841. default:
  842. result = CFrameWnd::WindowProc(WM_NCLBUTTONDOWN,wParam,lParam);
  843. break;
  844. }
  846. RTDrawTitleBar(&dc,m_bActive);
  847. return result;
  848. }
  850. LRESULT CRTFrameWnd::OnRTNcLMouseUp(WPARAM wParam,LPARAM lParam)
  851. {
  852. if(!m_bEnableSkin)return CFrameWnd::WindowProc(WM_NCLBUTTONUP,wParam,lParam);
  853. if(!m_bEnableSkin)return CFrameWnd::WindowProc(WM_NCLBUTTONUP,wParam,lParam);
  855. LRESULT result = 0;
  856. if(m_NcMouseState == MouseStateNormal)
  857. {
  858. return CFrameWnd::WindowProc(WM_NCLBUTTONUP,wParam,lParam);
  859. }
  860. m_NcMouseState = MouseStateNormal;
  861. ReleaseCapture();
  863. if(wParam == HTMAXBUTTON)
  864. {
  865. if(m_SelTitleButton == MaximizeButton)
  866. {
  867. CWindowDC dc(this);
  868. m_SelTitleButton = NoneButton;
  869. m_MaximizeButtonState = StateNormal;
  870. RTDrawTitleBarButtons(&dc);
  871. if(IsZoomed())
  872. {
  873. SendMessage(WM_SYSCOMMAND, SC_RESTORE, lParam);
  874. }
  875. else
  876. {
  877. SendMessage(WM_SYSCOMMAND, SC_MAXIMIZE,lParam);
  878. }
  879. }
  880. }
  881. else if(wParam == HTMINBUTTON)
  882. {
  883. if(m_SelTitleButton == MinimizeButton)
  884. {
  885. CWindowDC dc(this);
  886. m_SelTitleButton = NoneButton;
  887. m_MinimizeButtonState = StateNormal;
  888. RTDrawTitleBarButtons(&dc);
  889. SendMessage(WM_SYSCOMMAND, SC_MINIMIZE,lParam);
  890. }
  891. }
  892. else if(wParam == HTCLOSE)
  893. {
  894. if(m_SelTitleButton == ExitButton)
  895. {
  896. //CWindowDC dc(this);
  897. m_SelTitleButton = NoneButton;
  898. m_ExitButtonState = StateNormal;
  899. //RTDrawTitleBarButtons(&dc);
  900. SendMessage(WM_SYSCOMMAND,SC_CLOSE,lParam);
  901. }
  902. }
  903. else
  904. {
  905. m_MinimizeButtonState = StateNormal;
  906. m_MaximizeButtonState = StateNormal;
  907. m_ExitButtonState = StateNormal;
  908. result = CFrameWnd::WindowProc(WM_NCLBUTTONUP,wParam,lParam);
  909. }
  913. return result;
  914. }
  916. LRESULT CRTFrameWnd::OnRTMouseMove(WPARAM wParam, LPARAM lParam)
  917. {
  918. if(!m_bEnableSkin)return CFrameWnd::WindowProc(WM_MOUSEMOVE,wParam,lParam);
  919. if(!m_bEnableTitleBar)return CFrameWnd::WindowProc(WM_MOUSEMOVE,wParam,lParam);
  921. if(m_NcMouseState != MouseStateNormal)
  922. {
  923. CRect rtWnd;
  924. GetWindowRect(&rtWnd);
  925. CPoint point(lParam);
  926. ClientToScreen(&point);
  927. UINT hit = (UINT)CFrameWnd::WindowProc(WM_NCHITTEST,wParam,MAKELPARAM(point.x,point.y));
  928. return OnRTNcMouseMove(hit,MAKELPARAM(point.x,point.y));
  929. }
  930. else
  931. {
  932. if(m_ExitButtonState != StateNormal || m_MinimizeButtonState != StateNormal || m_MaximizeButtonState != StateNormal)
  933. {
  934. CWindowDC dc(this);
  935. m_MaximizeButtonState = StateNormal;
  936. m_MinimizeButtonState = StateNormal;
  937. m_ExitButtonState = StateNormal;
  938. RTDrawTitleBarButtons(&dc);
  939. }
  940. }
  941. return CFrameWnd::WindowProc(WM_MOUSEMOVE,wParam,lParam);
  942. }
  944. LRESULT CRTFrameWnd::OnRTLButtonUp(WPARAM wParam, LPARAM lParam)
  945. {
  946. if(!m_bEnableSkin)return CFrameWnd::WindowProc(WM_LBUTTONUP,wParam,lParam);
  947. if(!m_bEnableTitleBar)return CFrameWnd::WindowProc(WM_LBUTTONUP,wParam,lParam);
  949. if(m_NcMouseState != MouseStateNormal)
  950. {
  951. CRect rtWnd;
  952. GetWindowRect(&rtWnd);
  953. CPoint point(lParam);
  954. ClientToScreen(&point);
  955. UINT hit = (UINT)CFrameWnd::WindowProc(WM_NCHITTEST,wParam,MAKELPARAM(point.x,point.y));
  956. return OnRTNcLMouseUp(hit,MAKELPARAM(point.x,point.y));
  957. }
  958. return CFrameWnd::WindowProc(WM_LBUTTONUP,wParam,lParam);
  959. }
  961. BOOL CRTFrameWnd::LoadFrame (UINT nIDResource, DWORD dwDefaultStyle, CWnd* pParentWnd, CCreateContext* pContext)
  962. {
  963.     if ( !CFrameWnd::LoadFrame (nIDResource, dwDefaultStyle, pParentWnd, pContext) )
  964.     {
  965.         return false;
  966.     }
  967.  
  968.     return true;
  969. }
  971. LRESULT CRTFrameWnd::OnRTSysCommand(WPARAM wParam,LPARAM lParam)
  972. {
  973. if(!m_bEnableSkin)return CFrameWnd::WindowProc(WM_SYSCOMMAND,wParam,lParam);
  974. if(!m_bEnableTitleBar)return CFrameWnd::WindowProc(WM_SYSCOMMAND,wParam,lParam);
  976. if(wParam != SC_CLOSE)
  977. {
  978. CWindowDC dc(this);
  979. RTDrawTitleBar(&dc,m_bActive);
  980. }
  981. return CFrameWnd::WindowProc(WM_SYSCOMMAND,wParam,lParam);
  982. }
  984. LRESULT CRTFrameWnd::OnRTSetCursor(WPARAM wParam,LPARAM lParam)
  985. {
  986. LRESULT rt = CFrameWnd::WindowProc(WM_SETCURSOR,wParam,lParam); 
  987. if(!m_bEnableSkin)return rt;
  988. if(!m_bEnableTitleBar)return rt;
  990. UINT nHitTest = LOWORD(lParam);
  991. if(m_bEnableSkin)
  992. {
  993. CWindowDC dc(this);
  994. switch(nHitTest)
  995. {
  996. case HTBORDER:
  997. case HTLEFT:
  998. case HTRIGHT:
  999. case HTTOP:
  1000. case HTBOTTOM:
  1001. case HTBOTTOMLEFT:
  1002. case HTBOTTOMRIGHT:
  1003. case HTTOPLEFT:
  1004. case HTTOPRIGHT:
  1005. RTDrawTitleBar(&dc,m_bActive);
  1006. break;
  1007. default:
  1008. break;
  1009. }
  1011. }
  1013. return rt;
  1014. }
  1018. LRESULT CRTFrameWnd::OnRTNcHitTest(WPARAM wParam, LPARAM lParam)
  1019. {
  1020. LRESULT lrst = CFrameWnd::WindowProc(WM_NCHITTEST,wParam,lParam);
  1021. return lrst;
  1022. }
  1024. LRESULT CRTFrameWnd::WindowProc(UINT message, WPARAM wParam, LPARAM lParam)
  1025. {
  1026. switch(message)
  1027. {
  1028. case WM_INITMENUPOPUP:
  1029. if(m_bEnableSkin && m_bEnableTitleBar)
  1030. {
  1031. CWindowDC dc(this);
  1032. RTDrawTitleBar(&dc,m_bActive);
  1033. }
  1034. break;
  1035. case WM_NCPAINT:
  1036. return OnRTNcPaint(wParam,lParam);
  1037. case WM_NCACTIVATE:
  1038. return OnRTNcActive(wParam,lParam);
  1039. case WM_ACTIVATE:
  1040. return OnRTActive(wParam,lParam);
  1041. case WM_ACTIVATEAPP:
  1042. return OnRTActiveApp(wParam,lParam);
  1043. case WM_NOTIFY:
  1044. return OnRTNodify(wParam,lParam);
  1045. case WM_SETTEXT:
  1046. return OnRTSetText(wParam,lParam);
  1047. case WM_SETICON:
  1048. return OnRTSetIcon(wParam,lParam);
  1049. case WM_NCMOUSEMOVE:
  1050. return OnRTNcMouseMove(wParam,lParam);
  1051. case WM_NCLBUTTONDOWN:
  1052. return OnRTNcLMouseDown(wParam,lParam);
  1053. case WM_NCLBUTTONUP:
  1054. OnRTNcLMouseUp(wParam,lParam);
  1055. case WM_LBUTTONUP:
  1056. return OnRTLButtonUp(wParam,lParam);
  1057. case WM_MOUSEMOVE:
  1058. return OnRTMouseMove(wParam,lParam);
  1059. case WM_SYSCOMMAND:
  1060. return OnRTSysCommand(wParam,lParam);
  1061. case WM_SETCURSOR:
  1062. return OnRTSetCursor(wParam,lParam);
  1063. default:
  1064. break;
  1065. }
  1067. return CFrameWnd::WindowProc(message, wParam, lParam);
  1068. }