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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 界面编程 > 组合框控件 > 查看源码
SkinWin.cpp
资源名称：vc一个皮肤.zip　[点击查看]
上传用户：vipseo
上传日期：2010-02-15
资源大小：137k
文件大小：30k
源码类别：

组合框控件

开发平台：

Visual C++

SkinWin.cpp：源码内容
  1. // SkinWin.cpp: implementation of the CSkinWin class.
  2. //
  3. // A class to enable draw windows-blind style window
  4. //
  5. //  ToDo:
  6. // how to popup system menu by my program??
  7. //
  8. // History:
  9. // 2002.11.24
  10. // CAN WORK NOW.
  11. // 2002.11.23 intial version
  12. //
  13. //
  14. //
  15. // AUthor:
  16. // szhao00@mails.tsinghua.edu.cn
  17. //
  18. //////////////////////////////////////////////////////////////////////
  20. #include "stdafx.h"
  22. #include "SkinWin.h"
  24. #ifdef _DEBUG
  25. #undef THIS_FILE
  26. static char THIS_FILE[]=__FILE__;
  27. #define new DEBUG_NEW
  28. #endif
  30. //////////////////////////////////////////////////////////////////////
  31. // Construction/Destruction
  32. //////////////////////////////////////////////////////////////////////
  34. CSkinWin::CSkinWin()
  35. {
  36. m_bInit = FALSE;
  37. m_winstate = 0;
  39. m_barcolor = RGB(207,207,207);
  40. m_menucolor = RGB(207,207,207);
  41. }
  43. CSkinWin::~CSkinWin()
  44. {
  46. }
  48. CString GetPathName( const char * filename );
  49. CString GetFileName( const char * filename, int ext = 0);
  50. char *next_token( char *buf, char *token, char *stopchars );
  52. COLORREF ReadColor( CString section, CString key, CString file, COLORREF defcolor )
  53. {
  54. char buf[1000];
  55. GetPrivateProfileString( section, key, "", buf, 1000, file );
  56. if ( *buf )
  57. {
  58. char token[255];
  59. char *p = buf;
  60. int r, g, b;
  61. p = next_token( p, token, NULL );
  62. r = atoi(token);
  63. p = next_token( p, token, NULL );
  64. g = atoi(token);
  65. p = next_token( p, token, NULL );
  66. b = atoi(token);
  67. return RGB(r, g, b );
  68. }
  69. else
  70. return defcolor;
  71. }
  73. BOOL CSkinWin::LoadSkin( const char * skinfile )
  74. {
  75. static const char * ps = "Personality";
  76. char buf[1000];
  77. CString path = GetPathName( skinfile );
  79. if ( m_bInit )
  80. {
  81. m_bmpDlg.DeleteObject();
  82. m_bmpTitle.DeleteObject();
  83. m_bmpLeft.DeleteObject();
  84. m_bmpRight.DeleteObject();
  85. m_bmpBottom.DeleteObject();
  86. m_bmpMaxBtn.DeleteObject();
  87. m_bmpRestoreBtn.DeleteObject();
  88. m_bmpMinBtn.DeleteObject();
  89. m_bmpCloseBtn.DeleteObject();
  91. //set deafult
  92. m_barcolor = RGB(207,207,207);
  93. m_menucolor = RGB(207,207,207);
  95. m_bInit = FALSE;
  96. }
  98. GetPrivateProfileString( ps, "DialogBmp", "", buf, 1000, skinfile );
  99. if ( *buf != 0 )
  100. m_bmpDlg.LoadBitmap( path + "/" + GetFileName( buf,1 ));
  103. GetPrivateProfileString( ps, "Top", "", buf, 1000, skinfile );
  104. if ( *buf == 0 || !m_bmpTitle.LoadBitmap( path + "/" + GetFileName( buf,1 )) )
  105. return FALSE;
  106. GetPrivateProfileString( ps, "Left", "", buf, 1000, skinfile );
  107. if ( *buf == 0 || !m_bmpLeft.LoadBitmap( path + "/" + GetFileName( buf,1 ) )) 
  108. return FALSE;
  109. GetPrivateProfileString( ps, "Right", "", buf, 1000, skinfile );
  110. if ( *buf == 0 || !m_bmpRight.LoadBitmap( path + "/" + GetFileName( buf,1 ) )) 
  111. return FALSE;
  112. GetPrivateProfileString( ps, "Bottom", "", buf, 1000, skinfile );
  113. if ( *buf == 0 || !m_bmpBottom.LoadBitmap( path + "/" + GetFileName( buf,1 ) )) 
  114. return FALSE;
  116. m_TitleHeight = m_bmpTitle.Height()/2;
  117. m_BorderLeftWidth = m_bmpLeft.Width()/2;
  118. m_BorderRightWidth = m_bmpRight.Width()/2;
  119. m_BorderBottomHeight = m_bmpBottom.Height()/2;
  121. m_titleoff1 = GetPrivateProfileInt( ps, "TopTopHeight", 0, skinfile );
  122. m_titleoff2 = m_bmpTitle.Width() - GetPrivateProfileInt( ps, "TopBotHeight", 0, skinfile );
  123. if ( m_titleoff2 <= m_titleoff1 )
  124. m_titleoff2 = m_titleoff1 + 1;
  125. m_leftoff1 = GetPrivateProfileInt( ps, "LeftTopHeight", 0, skinfile );
  126. m_leftoff2 = m_bmpLeft.Height() - GetPrivateProfileInt( ps, "LeftBotHeight", 0, skinfile );
  127. if ( m_leftoff2 <= m_leftoff1 )
  128. m_leftoff2 = m_leftoff1 + 1;
  130. m_rightoff1 = GetPrivateProfileInt( ps, "RightTopHeight", 0, skinfile );
  131. m_rightoff2 = m_bmpRight.Height() - GetPrivateProfileInt( ps, "RightBotHeight", 0, skinfile );
  132. if ( m_rightoff2 <= m_rightoff1 )
  133. m_rightoff2 = m_rightoff1 + 1;
  135. m_bottomoff1 = GetPrivateProfileInt( ps, "BottomTopHeight", 0, skinfile );
  136. m_bottomoff2 = m_bmpBottom.Width() - GetPrivateProfileInt( ps, "BottomBotHeight", 0, skinfile );
  137. if ( m_bottomoff2 <= m_bottomoff1 )
  138. m_bottomoff2 = m_bottomoff1 + 1;
  140. //load buttons
  141. int count = GetPrivateProfileInt( ps, "ButtonCount", 0, skinfile );
  142. int icount = GetPrivateProfileInt( ps, "ButtonImgCount", 3, skinfile );
  143. for ( int i = 0; i < count; i++ )
  144. {
  145. CString sec;
  146. sec.Format( "Button%d", i );
  147. GetPrivateProfileString( sec, "ButtonImage", "", buf, 1000, skinfile );
  148. int action = GetPrivateProfileInt( sec, "Action", 0,  skinfile );
  149. int x = GetPrivateProfileInt( sec, "XCoord", 0, skinfile );
  150. int y = GetPrivateProfileInt( sec, "YCoord", 0, skinfile );
  152. int state = icount;
  153. if ( action == 0 )
  154. {
  155. //close
  156. if ( !m_bmpCloseBtn.LoadBitmap( path + "/" + GetFileName( buf,1 )) ) 
  157. return FALSE;
  158. //state = m_bmpCloseBtn.Width()/m_bmpCloseBtn.Height();
  159. m_rectCloseBtn = CRect( x-m_bmpCloseBtn.Width()/state, y, x , y + m_bmpCloseBtn.Height() );
  160. }
  161. if ( action == 2 )
  162. {
  163. //min
  164. if ( !m_bmpMinBtn.LoadBitmap( path + "/" + GetFileName( buf,1 )) ) 
  165. return FALSE;
  166. //state = m_bmpMinBtn.Width()/m_bmpMinBtn.Height();
  167. m_rectMinBtn = CRect( x-m_bmpMinBtn.Width()/state, y, x, y + m_bmpMinBtn.Height() );
  168. }
  169. if ( action == 1 )
  170. {
  171. if ( !m_bmpMaxBtn.GetSafeHandle() )
  172. {
  173. //max
  174. if ( !m_bmpMaxBtn.LoadBitmap( path + "/" + GetFileName( buf,1 )) ) 
  175. return FALSE;
  176. //state = m_bmpMaxBtn.Width()/m_bmpMaxBtn.Height();
  177. m_rectMaxBtn = CRect( x-m_bmpMaxBtn.Width()/state, y, x , y + m_bmpMaxBtn.Height() );
  178. }
  179. else
  180. {
  181. //restore
  182. if ( !m_bmpRestoreBtn.LoadBitmap( path + "/" + GetFileName( buf,1 )) ) 
  183. return FALSE;
  184. //state = m_bmpRestoreBtn.Width()/m_bmpRestoreBtn.Height();
  185. m_rectRestoreBtn = CRect( x-m_bmpRestoreBtn.Width()/state, y, x , y + m_bmpRestoreBtn.Height() );
  186. }
  187. }
  188. if ( action == 4 )
  189. {
  190. }
  191. }
  192. m_textShift = GetPrivateProfileInt( ps, "TextShift", 0, skinfile );
  193. m_textShiftVer = GetPrivateProfileInt( ps, "TextShiftVert", 0, skinfile );
  195. char * colours = "Colours";
  196. m_colTitle1 = ReadColor(colours, "TitleText", skinfile, GetSysColor(COLOR_CAPTIONTEXT) );
  197. m_colTitle2 = ReadColor(colours, "InactiveTitleText", skinfile, GetSysColor(COLOR_CAPTIONTEXT) );
  199. m_bTrans = GetPrivateProfileInt( ps, "UsesTran", 0, skinfile );
  200. if ( m_bTrans )
  201. m_colTrans = ReadColor(colours, "TransColor", skinfile, RGB(255,0,255) );
  204. m_barcolor = ReadColor(colours, "BarColor", skinfile, RGB(207,207,207) );
  205. m_menucolor = ReadColor(colours, "MenuColor", skinfile, RGB(207,207,207) );
  207. m_btnbgcolor = ReadColor(colours, "ButtonFace", skinfile, GetSysColor(COLOR_BTNFACE) );
  208. m_btntextcolor = ReadColor(colours, "ButtonText", skinfile, GetSysColor(COLOR_BTNTEXT));
  209. m_btnhovercolor = ReadColor(colours, "ButtonHilight", skinfile, GetSysColor(COLOR_BTNFACE) );
  210. m_btnfocuscolor = ReadColor(colours, "ButtonFocus", skinfile, GetSysColor(COLOR_BTNFACE) );
  213. m_bInit = TRUE;
  214. return TRUE;
  215. }
  217. BOOL CSkinWin::DrawTitle(CDC *pDC, int x, int y, int w, int state)
  218. {
  219. int padding; 
  220. int ox = x;
  221. padding = ( w - m_bmpTitle.Width() )/( m_titleoff2 - m_titleoff1 ) + 1 ;
  222. if ( padding < 0 ) padding = 0;
  224. RECT sr;
  225. if ( state == 0 )
  226. sr = CRect( 0, 0, m_titleoff1, m_TitleHeight );
  227. else
  228. sr = CRect( 0, m_TitleHeight, m_titleoff1, m_bmpTitle.Height()  );
  229. m_bmpTitle.Draw( pDC, x, y, &sr );
  230.  
  231. x += m_titleoff1;
  232. if ( state == 0 )
  233. sr = CRect(  m_titleoff1, 0, m_titleoff2, m_TitleHeight );
  234. else
  235. sr = CRect(  m_titleoff1, m_TitleHeight, m_titleoff2, m_bmpTitle.Height()  );
  237. for ( int i = 0; i <= padding; i++, x += m_titleoff2 - m_titleoff1 )
  238. {
  239. int d = ( x + m_titleoff2 - m_titleoff1 - ox - w);
  240. if ( d > 0 )
  241. sr.right = sr.right - d;
  242. m_bmpTitle.Draw( pDC, x, y, &sr );
  243. }
  245. x = ox + w - ( m_bmpTitle.Width() - m_titleoff2 ) + 1 ;
  246. if ( state == 0 )
  247. sr = CRect(  m_titleoff2, 0, m_bmpTitle.Width()-1, m_TitleHeight);
  248. else
  249. sr = CRect(  m_titleoff2, m_TitleHeight, m_bmpTitle.Width()-1, m_bmpTitle.Height()  );
  250. m_bmpTitle.Draw( pDC, x, y, &sr );
  251. return TRUE;
  252. }
  254. BOOL CSkinWin::DrawBottom(CDC *pDC, int x, int y, int w, int state)
  255. {
  256. int padding; 
  257. int ox = x;
  258. padding = ( w - m_bmpBottom.Width() )/( m_bottomoff2 - m_bottomoff1 ) + 1 ;
  259. if ( padding < 0 ) padding = 0;
  261. RECT sr;
  262. if ( state == 0 )
  263. sr = CRect( 0, 0, m_bottomoff1, m_BorderBottomHeight);
  264. else
  265. sr = CRect( 0, m_BorderBottomHeight, m_bottomoff1, m_bmpBottom.Height()  );
  266. m_bmpBottom.Draw( pDC, x, y, &sr );
  268. x += m_bottomoff1;
  269. if ( state == 0 )
  270. sr = CRect(  m_bottomoff1, 0, m_bottomoff2, m_BorderBottomHeight );
  271. else
  272. sr = CRect(  m_bottomoff1, m_BorderBottomHeight, m_bottomoff2, m_bmpBottom.Height() );
  274. for ( int i = 0; i <= padding; i++, x += m_bottomoff2 - m_bottomoff1 )
  275. {
  276. int d = ( x + m_bottomoff2 - m_bottomoff1 - ox - w);
  277. if ( d > 0 )
  278. sr.right = sr.right - d;
  279. m_bmpBottom.Draw( pDC, x, y, &sr );
  280. }
  282. x = ox + w - ( m_bmpBottom.Width() - m_bottomoff2 );
  283. if ( state == 0 )
  284. sr = CRect(  m_bottomoff2, 0, m_bmpBottom.Width()-1, m_BorderBottomHeight );
  285. else
  286. sr = CRect(  m_bottomoff2, m_BorderBottomHeight, m_bmpBottom.Width()-1, m_bmpBottom.Height()  );
  287. m_bmpBottom.Draw( pDC, x, y, &sr );
  288. return TRUE;
  289. }
  291. BOOL CSkinWin::DrawLeft(CDC *pDC, int x, int y, int h, int state)
  292. {
  293. int padding; 
  294. int oy = y;
  295. padding = ( h - m_bmpLeft.Height() )/( m_leftoff2 - m_leftoff1 ) + 1 ;
  296. if ( padding < 0 ) padding = 0;
  298. RECT sr;
  299. if ( state == 0 )
  300. sr = CRect( 0, 0, m_BorderLeftWidth, m_leftoff1 );
  301. else
  302. sr = CRect( m_BorderLeftWidth, 0, m_bmpLeft.Width(), m_leftoff1  );
  303. m_bmpLeft.Draw( pDC, x, y, &sr );
  305. y += m_leftoff1;
  306. if ( state == 0 )
  307. sr = CRect(  0, m_leftoff1,  m_BorderLeftWidth, m_leftoff2 );
  308. else
  309. sr = CRect(  m_BorderLeftWidth, m_leftoff1, m_bmpLeft.Width(), m_leftoff2 );
  311. for ( int i = 0; i <= padding; i++, y += m_leftoff2 - m_leftoff1 )
  312. {
  313. int d = ( y + m_leftoff2 - m_leftoff1 - oy - h);
  314. if ( d > 0 )
  315. sr.bottom = sr.bottom - d;
  316. m_bmpLeft.Draw( pDC, x, y, &sr );
  317. }
  319. y = oy + h - ( m_bmpLeft.Height() - m_leftoff2 ) ;
  320. if ( state == 0 )
  321. sr = CRect(  0, m_leftoff2, m_BorderLeftWidth, m_bmpLeft.Height());
  322. else
  323. sr = CRect(  m_BorderLeftWidth, m_leftoff2,  m_bmpLeft.Width(), m_bmpLeft.Height()  );
  324. m_bmpLeft.Draw( pDC, x, y, &sr );
  326. return TRUE;
  327. }
  329. BOOL CSkinWin::DrawRight(CDC *pDC, int x, int y, int h, int state)
  330. {
  331. int padding; 
  332. int oy = y;
  333. padding = ( h - m_bmpRight.Height() )/( m_rightoff2 - m_rightoff1 ) + 1 ;
  334. if ( padding < 0 ) padding = 0;
  336. RECT sr;
  337. if ( state == 0 )
  338. sr = CRect( 0, 0, m_BorderRightWidth, m_rightoff1 );
  339. else
  340. sr = CRect( m_BorderRightWidth, 0, m_bmpRight.Width(), m_rightoff1  );
  341. m_bmpRight.Draw( pDC, x, y, &sr );
  343. y += m_rightoff1;
  344. if ( state == 0 )
  345. sr = CRect(  0, m_rightoff1,  m_BorderRightWidth, m_rightoff2 );
  346. else
  347. sr = CRect(  m_BorderRightWidth, m_rightoff1, m_bmpRight.Width(), m_rightoff2 );
  349. for ( int i = 0; i <= padding; i++, y += m_rightoff2 - m_rightoff1 )
  350. {
  351. int d = ( y + m_rightoff2 - m_rightoff1 - oy - h);
  352. if ( d > 0 )
  353. sr.bottom = sr.bottom - d;
  354. m_bmpRight.Draw( pDC, x, y, &sr );
  355. }
  357. y = oy + h - ( m_bmpRight.Height() - m_rightoff2 ) ;
  358. if ( state == 0 )
  359. sr = CRect(  0, m_rightoff2, m_BorderRightWidth, m_bmpRight.Height());
  360. else
  361. sr = CRect(  m_BorderRightWidth, m_rightoff2,  m_bmpRight.Width(), m_bmpRight.Height()  );
  362. m_bmpRight.Draw( pDC, x, y, &sr );
  364. return TRUE;
  366. }
  368. BOOL CSkinWin::DrawFrame(CDC *pDC, int x, int y, int w, int h, int state, int title )
  369. {
  370. if ( title )
  371. DrawTitle( pDC, x + m_BorderLeftWidth , y, 
  372.     w - m_BorderRightWidth - m_BorderLeftWidth + 1, state );
  373. DrawLeft( pDC, x, y, h, state );
  374. DrawRight( pDC, x + w - m_BorderRightWidth , y, h, state );
  375. DrawBottom( pDC, x + m_BorderLeftWidth, 
  376. y + h - m_BorderBottomHeight, w - m_BorderRightWidth - m_BorderLeftWidth, state );
  377. return TRUE;
  379. }
  381. BOOL CSkinWin::InstallSkin(CWnd *wnd)
  382. {
  383. if ( !wnd  || !m_bInit ) return FALSE;
  384. HookWindow( (HWND)NULL);
  385. int r = HookWindow( wnd );
  387. DWORD style = GetWindowLong( m_hWnd, GWL_STYLE );
  388. m_sizable = style & WS_SIZEBOX;
  389. m_minable = style & WS_MINIMIZEBOX;
  390. m_maxable = style & WS_MAXIMIZEBOX;
  391. //m_sysmenu = style & WS_MAXIMIZEBOX;
  392. style &= ~(WS_MINIMIZEBOX);
  393. style &= ~WS_MAXIMIZEBOX;
  394. style &= ~WS_SYSMENU;
  395. SetWindowLong( m_hWnd, GWL_STYLE, style );
  397. return r;
  398. }
  400. LRESULT CSkinWin::WindowProc(UINT msg, WPARAM wp, LPARAM lp)
  401. {
  402. if ( !IsWindow(m_hWnd) )
  403. return 0;
  404. if ( !m_bInit  ) 
  405. return Default();
  407. switch ( msg )
  408. {
  409. case WM_SHOWWINDOW:
  410. //call setwindowpos to force OnNcCalcSize when hWnd is a dialog
  411. if ( wp )
  412. SetWindowPos( m_hWnd, 0, 0, 0, 400, 400, SWP_NOSIZE|SWP_NOMOVE|SWP_FRAMECHANGED );
  413. Default();
  414. return 0;
  415. break;
  416. //case WM_ERASEBKGND:
  417. case WM_INITMENUPOPUP:
  418. Default();
  419. return 0;
  420. // return OnEraseBkgnd(CDC::FromHandle((HDC)wp) );
  421. /*
  422. case WM_INITMENU:
  423. //a hack, when popup sysmenu, redraw title bar
  424. HMENU h;
  425. h = (HMENU)wp;
  426. int c;
  427. h = GetSubMenu(h, 0);
  428. c = GetMenuItemID( h, 0 );
  429. if ( c == SC_RESTORE )
  430. {
  431. CRect r;
  432. GetClientRect( m_hWnd, r );
  433. OnNcPaint(0);
  434. r.bottom = GetSystemMetrics(SM_CYCAPTION);
  435. InvalidateRect( m_hWnd, r, TRUE );
  436. UpdateWindow( m_hWnd );
  437. }
  438. Default();
  439. return 0;
  440. */
  441. case WM_SYSCOMMAND:
  442. OnSysCommand( wp, lp );
  443. //Default();
  444. return 0;
  445. case WM_SETTEXT:
  446. return OnSetText( wp, lp );
  447. case WM_NCPAINT:
  448. OnNcPaint( (HRGN)wp );
  449. return 0;
  450. case WM_NCCALCSIZE:
  451. OnNcCalcSize( (BOOL)wp, (NCCALCSIZE_PARAMS *)lp );
  452. return 0;
  453. case WM_SIZE:
  454. OnSize( wp, LOWORD(lp), HIWORD(lp) );
  455. return 0;
  456. case WM_NCACTIVATE:
  457. return OnNcActivate( (BOOL)wp );
  458. case WM_NCHITTEST:
  459. return OnNcHitTest(CPoint(LOWORD(lp), HIWORD(lp)));
  460. case WM_NCLBUTTONUP:
  461. OnNcLButtonUp(wp, CPoint(LOWORD(lp), HIWORD(lp)));
  462. return 0;
  463. case WM_NCLBUTTONDOWN:
  464. OnNcLButtonDown(wp, CPoint(LOWORD(lp), HIWORD(lp)));
  465. return 0;
  466. case WM_NCLBUTTONDBLCLK:
  467. OnNcLButtonDblClk(wp, CPoint(LOWORD(lp), HIWORD(lp)));
  468. return 0;
  469. case WM_NCRBUTTONUP:
  470. OnNcRButtonUp(wp, CPoint(LOWORD(lp), HIWORD(lp)));
  471. return 0;
  472. case WM_NCRBUTTONDOWN:
  473. OnNcRButtonDown(wp, CPoint(LOWORD(lp), HIWORD(lp)));
  474. return 0;
  475. case WM_NCMOUSEMOVE:
  476. OnNcMouseMove( wp,CPoint(LOWORD(lp), HIWORD(lp)));
  477. return 0;
  478. case WM_GETMINMAXINFO:
  479. OnGetMinMaxInfo( (MINMAXINFO *)lp );
  480. return 0;
  481. case WM_WINDOWPOSCHANGING:
  482. OnWindowPosChanging((WINDOWPOS *)lp);
  483. return 0;
  484. case WM_SIZING:
  485. OnSizing( wp, (LPRECT)lp );
  486. return 0;
  487. case WM_ACTIVATE:
  488. OnActivate( wp, CWnd::FromHandle((HWND)lp), 0 );
  489. return 0;
  490. case WM_COMMAND:
  491. if ( !HandleSysCommand( wp, lp ) )
  492. Default();
  493. return 0;
  494. default:
  495. return Default();
  496. }
  497. }
  499. void CSkinWin::OnNcPaint(HRGN rgn1)
  500. {
  501. CWnd *pWnd = CWnd::FromHandle(m_hWnd);
  502. CDC * pDC = pWnd->GetWindowDC();
  503. CRect wr;
  504. pWnd->GetWindowRect( wr );
  506. //f ( (DWORD)rgn) 
  507. //pDC->SelectClipRgn( CRgn::FromHandle(rgn) );
  509. //m_bActive = GetActiveWindow() == m_hWnd;
  510. int state = 0;
  511. if ( m_bActive)
  512. state = 0;
  513. else state = 1;
  515. pDC->ExcludeClipRect(0, 0, wr.Width(), m_TitleHeight );
  516. DrawFrame( pDC, 0, 0, wr.Width(), wr.Height(), state, 0 );
  517. pDC->SelectClipRgn( NULL ); 
  519. CDC memDC, *pNewDC;
  520. CMyBitmap bmp;
  521. CBitmap  *obmp;
  522. memDC.CreateCompatibleDC( pDC );
  523. bmp.CreateCompatibleBitmap( pDC, wr.Width(), m_TitleHeight );
  524. obmp = memDC.SelectObject(&bmp);
  525. pNewDC = &memDC;
  527. DrawTitle( pNewDC, m_BorderLeftWidth , 0, 
  528.     wr.Width() - m_BorderRightWidth - m_BorderLeftWidth + 1, state );
  529. DrawLeft( pNewDC, 0, 0, m_bmpLeft.Height(), state );
  530. DrawRight( pNewDC, wr.Width() - m_BorderRightWidth , 0, m_bmpRight.Height(), state );
  533. CRgn newrgn;
  534. newrgn.CreateRectRgn( 0, 0, wr.Width(), wr.Height() );
  535. if ( m_bTrans )
  536. {
  537. CRgn rgn;
  538. rgn.CreateRectRgn( 0, m_TitleHeight, wr.Width(), wr.Height() );
  539. HRGN hrgn = bmp.CreateRgnFromFile( m_colTrans );
  540. newrgn.CombineRgn( &rgn, CRgn::FromHandle(hrgn), RGN_XOR  );
  541. pDC->SelectClipRgn( &newrgn ); 
  542. }
  543. else
  544. SetWindowRgn( m_hWnd, newrgn, FALSE );
  546. if ( m_downHitTest == HTCLOSE )
  547. DrawButton( pNewDC, 0, 1 );
  548. else if ( m_moveHitTest == HTCLOSE)
  549. DrawButton( pNewDC, 0, 2 );
  550. else
  551. DrawButton( pNewDC, 0, 0 );
  553. if ( m_downHitTest == HTMINBUTTON )
  554. DrawButton( pNewDC, 2, 1 );
  555. else if ( m_moveHitTest == HTMINBUTTON)
  556. DrawButton( pNewDC, 2, 2 );
  557. else
  558. DrawButton( pNewDC, 2, 0 );
  560. if ( m_downHitTest == HTMAXBUTTON )
  561. DrawButton( pNewDC, 1, 1 );
  562. else if ( m_moveHitTest == HTMAXBUTTON)
  563. DrawButton( pNewDC, 1, 2 );
  564. else
  565. DrawButton( pNewDC, 1, 0 );
  567. int cx = GetSystemMetrics(SM_CXSMICON);
  568. int cy = GetSystemMetrics(SM_CYSMICON);
  569. HICON hi = (HICON)SendMessage( m_hWnd, WM_GETICON, ICON_SMALL, 0);
  570. if ( !hi )
  571. {
  572. #ifdef IDR_MAINFRAME
  573. hi = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
  574. #endif
  575. }
  576. //draw icon
  577. ::DrawIconEx( pNewDC->GetSafeHdc(), m_BorderLeftWidth, 5, (HICON)
  578. CopyImage( hi, IMAGE_ICON, 
  579. cx, cy, 0), cx, cy, 0, 0, DI_NORMAL);
  580. //draw text
  581. if ( m_title.IsEmpty() )
  582. pWnd->GetWindowText(m_title);
  584. if (m_bActive)
  585. pNewDC->SetTextColor( m_colTitle1 );
  586. else
  587. pNewDC->SetTextColor( m_colTitle2 );
  589. CFont font, *ofont;
  590. font.CreatePointFont( GetSystemMetrics(SM_CYSMCAPTION), "System" );
  591. ofont = pNewDC->SelectObject(&font);
  593. pNewDC->SetBkMode(TRANSPARENT);
  594. pNewDC->DrawText( m_title, CRect( m_textShift, m_textShiftVer, wr.Width() - m_bmpTitle.Width() + m_titleoff2, 
  595. m_TitleHeight ), DT_SINGLELINE | DT_LEFT | DT_VCENTER | DT_WORD_ELLIPSIS  );
  597. pNewDC->SelectObject(&font);
  599. pDC->BitBlt( 0, 0, wr.Width(),
  600. m_TitleHeight, pNewDC, 0, 0, SRCCOPY );
  601. memDC.SelectObject(obmp);
  603. pDC->SelectClipRgn(NULL);
  604. }
  606. void CSkinWin::OnNcCalcSize(BOOL bCalcValidRects, NCCALCSIZE_PARAMS *lpncsp)
  607. {
  608. if ( bCalcValidRects )
  609. {
  610. lpncsp->rgrc[0].left = lpncsp->rgrc[0].left + m_BorderLeftWidth;
  611. lpncsp->rgrc[0].right = lpncsp->rgrc[0].right - m_BorderRightWidth;
  612. lpncsp->rgrc[0].top = lpncsp->rgrc[0].top + m_TitleHeight;
  613. lpncsp->rgrc[0].bottom = lpncsp->rgrc[0].bottom - m_BorderBottomHeight;
  614. lpncsp->rgrc[1] = lpncsp->rgrc[0];
  616. }
  617. else
  618. {
  619. Default();
  620. }
  622. }
  624. void CSkinWin::OnSizing(UINT nSide, LPRECT lpRect)
  625. {
  626. //Default();
  627. CWnd *pWnd = CWnd::FromHandle(m_hWnd);
  628. CRect wr(lpRect);
  630. /*
  631. if ( m_bTrans )
  632. SetWindowRgn( m_hWnd, GetRegion(wr.Width(), wr.Height() ), TRUE );
  633. else
  634. SetWindowRgn( m_hWnd, NULL, TRUE );
  635. */
  636. }
  639. void CSkinWin::OnSize(UINT nType, int cx, int cy)
  640. {
  641. //Default();
  642. CWnd *pWnd = CWnd::FromHandle(m_hWnd);
  643. CRect wr;
  644. Default();
  645. pWnd->GetWindowRect(wr);
  646. pWnd->Invalidate();
  647. OnNcPaint(0);
  649. if ( m_bTrans )
  650. SetWindowRgn( m_hWnd, GetRegion(wr.Width(), wr.Height() ), TRUE );
  651. else
  652. SetWindowRgn( m_hWnd, NULL, TRUE );
  655. }
  657. HRGN CSkinWin::GetRegion(int w, int h)
  658. {
  659. CWnd *pWnd = CWnd::FromHandle(m_hWnd);
  660. CRect wr;
  661. pWnd->GetWindowRect(wr);
  663. CRgn rgn;
  664. if ( m_bTrans )
  665. {
  666. CDC *pDC = pWnd->GetDC();
  667. CDC memDC;
  668. CMyBitmap bmp;
  669. CBitmap *obmp;
  670. memDC.CreateCompatibleDC(pDC);
  671. bmp.CreateCompatibleBitmap( pDC, w, m_TitleHeight );
  672. obmp = memDC.SelectObject(&bmp);
  673. /*
  674. memDC.FillSolidRect( 0, 0, w, h, 0 );
  675. DrawFrame( &memDC, 0, 0, w, h, 0 );
  676. */
  677. DrawTitle( &memDC, m_BorderLeftWidth , 0, 
  678.     wr.Width() - m_BorderRightWidth - m_BorderLeftWidth + 1, 0 );
  679. DrawLeft( &memDC, 0, 0, m_bmpLeft.Height(), 0 );
  680. DrawRight( &memDC, wr.Width() - m_BorderRightWidth , 0, m_bmpRight.Height(), 0 );
  682. memDC.SelectObject(obmp);
  683. pWnd->ReleaseDC( pDC );
  685. rgn.CreateRectRgn( 0, m_TitleHeight, wr.Width(), wr.Height() );
  686. HRGN hrgn = bmp.CreateRgnFromFile( m_colTrans );
  687. CRgn newrgn;
  688. newrgn.CreateRectRgn( 0, m_TitleHeight, wr.Width(), wr.Height() );
  689. newrgn.CombineRgn( &rgn, CRgn::FromHandle(hrgn), RGN_XOR  );
  691. return (HRGN)newrgn.Detach();
  692. }
  693. else
  694. rgn.CreateRectRgn( 0, 0, wr.Width(), wr.Height() );
  697. return (HRGN)rgn.Detach();
  698. }
  701. BOOL CSkinWin::OnNcActivate(BOOL bActive)
  702. {
  703. m_bActive = bActive;
  704. OnNcPaint(0);
  705. if ( !bActive )
  706. {
  707. return 1;
  708. }
  709. else
  710. return 0;
  711. }
  715. UINT CSkinWin::OnNcHitTest(CPoint point)
  716. {
  717. CWnd *pWnd = CWnd::FromHandle(m_hWnd);
  718. CRect wr;
  719. pWnd->GetWindowRect(wr);
  721. point.x -= wr.left;
  722. point.y -= wr.top;
  723. if ( PtInRect( GetButtonRect(0), point ) )
  724. return HTCLOSE;
  725. if ( PtInRect( GetButtonRect(2), point ) && m_minable )
  726. return HTMINBUTTON;
  727. if ( PtInRect( GetButtonRect(1), point ) && m_maxable )
  728. return HTMAXBUTTON;
  730. CRect r;
  731. int cx = GetSystemMetrics(SM_CXSMICON);
  732. int cy = GetSystemMetrics(SM_CYSMICON);
  733. if ( PtInRect( CRect(m_BorderLeftWidth, 5, m_BorderLeftWidth + cx, cy + 5), point ) )
  734. return HTSYSMENU;
  736. r = CRect( 0, 0, m_BorderLeftWidth, m_TitleHeight );
  737. if ( PtInRect( r, point ) && m_sizable && m_winstate != 1 )  //!IsZoomed(m_hWnd) )
  738. return HTTOPLEFT;
  739. r = CRect( wr.Width() - m_BorderLeftWidth, 0,  wr.Width(), m_TitleHeight  );
  740. if ( PtInRect( r, point ) && m_sizable && m_winstate != 1 )  //!IsZoomed(m_hWnd) )
  741. return HTTOPRIGHT;
  742. r = CRect( 0, wr.Height() - m_BorderBottomHeight, m_BorderLeftWidth, wr.Height() );
  743. if ( PtInRect( r, point ) && m_sizable && m_winstate != 1 )  //!IsZoomed(m_hWnd) )
  744. return HTBOTTOMLEFT;
  745. r = CRect( wr.Width()-m_BorderRightWidth, wr.Height() - m_BorderBottomHeight,  wr.Width(), wr.Height() );
  746. if ( PtInRect( r, point ) && m_sizable && m_winstate != 1 )  //!IsZoomed(m_hWnd) )
  747. return HTBOTTOMRIGHT;
  748. r = CRect( 0, m_TitleHeight,  m_BorderLeftWidth, wr.Height() - m_BorderBottomHeight  );
  749. if ( PtInRect( r, point ) && m_sizable && m_winstate != 1 )  //!IsZoomed(m_hWnd) )
  750. return HTLEFT;
  751. r = CRect( wr.Width()-m_BorderRightWidth, m_TitleHeight,  wr.Width(), wr.Height() - m_BorderBottomHeight  );
  752. if ( PtInRect( r, point ) && m_sizable && m_winstate != 1 )  //!IsZoomed(m_hWnd) )
  753. return HTRIGHT;
  754. r = CRect( m_BorderLeftWidth, wr.Height() - m_BorderBottomHeight,  wr.Width()-m_BorderRightWidth, wr.Height() );
  755. if ( PtInRect( r, point ) && m_sizable && m_winstate != 1 )  //!IsZoomed(m_hWnd) )
  756. return HTBOTTOM;
  757. r = CRect( m_BorderLeftWidth, 0,  wr.Width()-m_BorderRightWidth, m_BorderBottomHeight );
  758. if ( PtInRect( r, point ) && m_sizable && m_winstate != 1 )  //!IsZoomed(m_hWnd) )
  759. return HTTOP;
  760. //set to boder 5
  761. r = CRect( m_BorderLeftWidth, 5 , wr.Width()-m_BorderRightWidth, m_TitleHeight );
  762. if ( PtInRect( r, point ) )
  763. return HTCAPTION;
  767. return HTCLIENT;
  768. }
  770. void CSkinWin::OnNcLButtonDblClk(UINT nHitTest, CPoint point)
  771. {
  772. if ( nHitTest == HTCAPTION && m_sizable )
  773. {
  774. if ( m_winstate == 1 )
  775. Restore();
  776. else
  777. Maximize(); //ShowWindow(m_hWnd, SW_MAXIMIZE);
  778. m_downHitTest = 0;
  779. m_moveHitTest = 0;
  780. OnNcPaint(0);
  781. }
  782. }
  784. void CSkinWin::OnNcLButtonDown(UINT nHitTest, CPoint point)
  785. {
  786. m_downHitTest = nHitTest;
  787. m_moveHitTest = m_downHitTest;
  789. OnNcPaint(0);
  790. if ( nHitTest >= HTLEFT && nHitTest <= HTBOTTOMRIGHT || 
  791. nHitTest == HTCAPTION && m_winstate != 1 )  //!IsZoomed(m_hWnd) )
  792. Default();
  793. else if ( nHitTest == HTSYSMENU )
  794. {
  795. PopupSysMenu(point);
  796. /*
  797. CWnd * pWnd = CWnd::FromHandle(m_hWnd);
  798. //a tricky hack
  799. pWnd->ModifyStyle( 0, WS_SYSMENU | WS_MINIMIZEBOX | WS_MAXIMIZEBOX );
  800. Default();
  801. pWnd->ModifyStyle( WS_SYSMENU | WS_MINIMIZEBOX | WS_MAXIMIZEBOX, 0 );
  802. */
  803. }
  804. }
  806. void CSkinWin::OnNcLButtonUp(UINT nHitTest, CPoint point)
  807. {
  808. if ( nHitTest == HTCLOSE )
  809. {
  810. SendMessage(m_hWnd, WM_CLOSE, 0, 0);
  811. return;
  812. }
  813. else if ( nHitTest == HTMINBUTTON )
  814. Minimize();
  815. else if ( nHitTest == HTMAXBUTTON )
  816. {
  817. if ( m_winstate == 1 ) // IsZoomed(m_hWnd) )
  818. Restore(); //ShowWindow(m_hWnd, SW_RESTORE);
  819. else
  820. Maximize(); //ShowWindow(m_hWnd, SW_MAXIMIZE);
  821. }
  822. else
  823. return;
  824. m_downHitTest = 0;
  825. m_moveHitTest = 0;
  826. OnNcPaint(0);
  828. }
  830. void CSkinWin::OnNcMouseMove(UINT nHitTest, CPoint point)
  831. {
  832. if ( nHitTest >= HTLEFT && nHitTest <= HTBOTTOMRIGHT || 
  833.  nHitTest == HTCAPTION && m_winstate != 1 )  //!IsZoomed(m_hWnd) )
  834. Default();
  836. m_moveHitTest = nHitTest;
  837. m_downHitTest = 0;
  838. if ( m_oldHitTest != nHitTest )
  839. {
  840. /*
  841. CRect r;
  842. r = GetButtonRect(0);
  843. r.UnionRect( r, GetButtonRect(1) );
  844. r.UnionRect( r, GetButtonRect(2) );
  845. CRgn rgn;
  846. rgn.CreateRectRgn( r.left, r.top, r.right, r.bottom );
  847. */
  848. OnNcPaint(0);
  849. m_oldHitTest = nHitTest;
  850. }
  852. }
  854. void CSkinWin::OnNcRButtonDown(UINT nHitTest, CPoint point)
  855. {
  856. if ( nHitTest == HTCAPTION )
  857. {
  858. /*
  859. CWnd * pWnd = CWnd::FromHandle(m_hWnd);
  860. pWnd->ModifyStyle( 0, WS_SYSMENU | WS_MINIMIZEBOX | WS_MAXIMIZEBOX );
  861. Default();
  862. pWnd->ModifyStyle( WS_SYSMENU | WS_MINIMIZEBOX | WS_MAXIMIZEBOX, 0 );
  863. */
  864. PopupSysMenu(point);
  865. }
  866. }
  868. void CSkinWin::OnNcRButtonUp(UINT nHitTest, CPoint point)
  869. {
  872. }
  874. CRect CSkinWin::GetButtonRect(int i)
  875. {
  876. CWnd *pWnd = CWnd::FromHandle(m_hWnd);
  877. CRect wr;
  878. pWnd->GetWindowRect(wr);
  880. CRect r;
  881. if ( i == 0 && m_bmpCloseBtn.GetSafeHandle() )
  882. {
  883. //close
  884. r = m_rectCloseBtn;
  885. r.left = wr.Width() - m_rectCloseBtn.right;
  886. r.right = wr.Width() - m_rectCloseBtn.left;
  887. }
  888. if ( i == 1 && m_bmpMaxBtn.GetSafeHandle())
  889. {
  890. //max
  892. if ( m_winstate != 1 || !m_bmpRestoreBtn.GetSafeHandle() )
  893. {
  894. r = m_rectMaxBtn;
  895. r.left = wr.Width() - m_rectMaxBtn.right;
  896. r.right = wr.Width() - m_rectMaxBtn.left;
  897. }
  898. else
  899. {
  900. r = m_rectRestoreBtn;
  901. r.left = wr.Width() - m_rectRestoreBtn.right;
  902. r.right = wr.Width() - m_rectRestoreBtn.left;
  903. }
  905. }
  906. if ( i == 2 && m_bmpMinBtn.GetSafeHandle())
  907. {
  908. //min
  909. r = m_rectMinBtn;
  910. r.left = wr.Width() - m_rectMinBtn.right;
  911. r.right = wr.Width() - m_rectMinBtn.left;
  912. }
  914. return r;
  916. }
  918. BOOL CSkinWin::DrawButton( CDC * pDC, int i, int state)
  919. {
  920. if ( i == 0 )
  921. {
  922. if ( m_bmpCloseBtn.GetSafeHandle() )
  923. {
  924. CRect r = GetButtonRect(0);
  925. m_bmpCloseBtn.Draw( pDC, r.left, r.top, 
  926. CRect( state * r.Width(), 0, (state + 1 ) * r.Width(), m_bmpCloseBtn.Height() ), m_colTrans, m_bTrans );
  927. }
  928. }
  929. if ( i == 1 )
  930. {
  931. CRect r = GetButtonRect(1);
  932. if ( m_maxable && m_bmpMaxBtn.GetSafeHandle() )
  933. if ( m_winstate == 1&& m_bmpRestoreBtn.GetSafeHandle() )
  934. m_bmpRestoreBtn.Draw( pDC, r.left, r.top, 
  935. CRect( state * r.Width(), 0, (state + 1 ) * r.Width(), m_bmpCloseBtn.Height() ), m_colTrans, m_bTrans );
  936. else
  937. m_bmpMaxBtn.Draw( pDC, r.left, r.top, 
  938. CRect( state * r.Width(), 0, (state + 1 ) * r.Width(), m_bmpCloseBtn.Height() ) , m_colTrans, m_bTrans);
  939. }
  940. if ( i == 2 )
  941. {
  942. if ( m_minable && m_bmpMinBtn.GetSafeHandle() )
  943. {
  944. CRect r = GetButtonRect(2);
  945. m_bmpMinBtn.Draw( pDC, r.left, r.top, 
  946. CRect( state * r.Width(), 0, (state + 1 ) * r.Width(), m_bmpCloseBtn.Height() ) , m_colTrans, m_bTrans);
  948. }
  949. }
  950. return TRUE;
  952. }
  954. void CSkinWin::OnGetMinMaxInfo(MINMAXINFO *lpMMI)
  955. {
  956. lpMMI->ptMinTrackSize = CPoint( m_bmpTitle.Width() + m_bmpLeft.Width() +
  957. m_bmpRight.Width(),  m_bmpLeft.Height() + 20 );
  958. }
  961. void CSkinWin::OnWindowPosChanging(WINDOWPOS *lpwndpos)
  962. {
  963. }
  966. BOOL CSkinWin::OnEraseBkgnd(CDC *pDC)
  967. {
  968. if ( m_bmpDlg.GetSafeHandle() )
  969. {
  970. CRect r;
  971. GetClientRect( m_hWnd, r);
  972. for ( int i = 0; i < r.Width()/m_bmpDlg.Width() + 1; i++ )
  973. for ( int j = 0; j < r.Height()/m_bmpDlg.Height() + 1; j++ )
  974. {
  975. m_bmpDlg.Draw( pDC, CRect( i *  m_bmpDlg.Width(), j * m_bmpDlg.Height(),
  976. i *  m_bmpDlg.Width() + m_bmpDlg.Width(), j * m_bmpDlg.Height() + m_bmpDlg.Height() ) );
  977. }
  979. return TRUE;
  980. }
  981. else
  982. return FALSE;
  983. }
  985. CRect CSkinWin::GetMaximizeRect()
  986. {
  987. CRect r;
  988. SystemParametersInfo(SPI_GETWORKAREA, 0, r, 0);
  990. return r;
  991. }
  993. BOOL CSkinWin::Maximize()
  994. {
  995. CRect r = GetMaximizeRect();
  996. GetWindowRect( m_hWnd, m_rectRestoreWin );
  997. m_winstate = 1;
  998. ::MoveWindow( m_hWnd, r.left, r.top, r.Width(), r.Height(), TRUE  );
  999. UpdateWindow( m_hWnd );
  1000. return TRUE;
  1001. }
  1003. BOOL CSkinWin::Minimize()
  1004. {
  1005. m_oldwinstate = m_winstate;
  1006. m_winstate = 2;
  1007. ShowWindow(m_hWnd, SW_MINIMIZE);
  1008. return TRUE;
  1009. }
  1011. BOOL CSkinWin::Restore()
  1012. {
  1013. if ( m_winstate == 1 )
  1014. {
  1015. ::MoveWindow( m_hWnd, m_rectRestoreWin.left, m_rectRestoreWin.top,
  1016. m_rectRestoreWin.Width(), m_rectRestoreWin.Height(), TRUE  );
  1017. m_winstate = 0;
  1018. UpdateWindow( m_hWnd );
  1019. }
  1020. return TRUE;
  1021. }
  1023. //void OnActivate(UINT nState,CWnd* pWndOther, BOOL bMinimized );
  1025. void CSkinWin::OnActivate(UINT nState, CWnd *pWndOther, BOOL bMinimized)
  1026. {
  1027. //Default();
  1028. m_bActive = ( nState == WA_ACTIVE || nState == WA_CLICKACTIVE );
  1029. OnNcActivate(m_bActive);
  1030. }
  1032. LRESULT CSkinWin::OnSetText(WPARAM wp, LPARAM lp)
  1033. {
  1034. char * str = ( char *)lp;
  1036. Default();
  1037. m_title = str;
  1038. OnNcPaint(0);
  1039. return 0;
  1040. }
  1044. void CSkinWin::OnSysCommand(UINT nID, LPARAM lParam)
  1045. {
  1046. if ( nID == SC_MAXIMIZE )
  1047. Maximize();
  1048. else if ( nID == SC_RESTORE && m_winstate == 1 )
  1049. Restore();
  1050. else if ( nID == SC_RESTORE && m_winstate == 2 )
  1051. {
  1052. ShowWindow( m_hWnd, SW_RESTORE );
  1053. m_winstate = m_oldwinstate;
  1054. OnNcPaint(0);
  1055. }
  1056. else 
  1057. Default();
  1058. }
  1060. BOOL CSkinWin::PopupSysMenu(CPoint point)
  1061. {
  1062. CWnd * pWnd = CWnd::FromHandle(m_hWnd);
  1063. CMenu SysMenu;
  1064. SysMenu.Attach( GetSystemMenu(m_hWnd, FALSE) );
  1069. /*
  1070.   when gray menuitem, a strange line appears!!
  1071.   
  1072. if ( m_winstate == 0 )
  1073. {
  1074. SysMenu.EnableMenuItem( SC_MINIMIZE, MF_BYCOMMAND|MF_ENABLED );
  1075. SysMenu.EnableMenuItem( SC_MAXIMIZE, MF_BYCOMMAND|MF_ENABLED );
  1076. SysMenu.EnableMenuItem( SC_RESTORE, MF_BYCOMMAND|MF_DISABLED|MF_GRAYED );
  1077. }
  1078. else if ( m_winstate == 1 )
  1079. {
  1080. SysMenu.EnableMenuItem( SC_MAXIMIZE, MF_BYCOMMAND|MF_DISABLED|MF_GRAYED );
  1081. SysMenu.EnableMenuItem( SC_RESTORE, MF_BYCOMMAND|MF_ENABLED );
  1082. }
  1083. else if ( m_winstate == 2 )
  1084. {
  1085. SysMenu.EnableMenuItem( SC_MINIMIZE, MF_BYCOMMAND|MF_DISABLED|MF_GRAYED );
  1086. SysMenu.EnableMenuItem( SC_RESTORE, MF_BYCOMMAND|MF_ENABLED );
  1087. }
  1088. */
  1090. SysMenu.TrackPopupMenu( 0, point.x, point.y, pWnd  );
  1091. SysMenu.Detach();
  1092. return TRUE;
  1093. }
  1095. BOOL CSkinWin::HandleSysCommand(WPARAM wp, LPARAM lp)
  1096. {
  1097. if ( lp == 0 )
  1098. {
  1099. CMenu SysMenu;
  1100. SysMenu.Attach( GetSystemMenu(m_hWnd, FALSE) );
  1101. int count = SysMenu.GetMenuItemCount();
  1102. for( int i = 0; i < count ; i++ )
  1103. if ( SysMenu.GetMenuItemID(i) == wp )
  1104. break;
  1105. SysMenu.Detach();
  1106. if ( i >= count )
  1107. return FALSE;
  1108. if ( wp == SC_MAXIMIZE )
  1109. Maximize();
  1110. else if ( wp == SC_MINIMIZE )
  1111. Minimize();
  1112. else if ( wp == SC_RESTORE && m_winstate == 1 )
  1113. Restore();
  1114. else if ( wp == SC_RESTORE && m_winstate == 2 )
  1115. {
  1116. ShowWindow( m_hWnd, SW_RESTORE );
  1117. m_winstate = m_oldwinstate;
  1118. OnNcPaint(0);
  1119. }
  1120. else 
  1121. SendMessage( m_hWnd, WM_SYSCOMMAND, wp, lp );
  1122. return TRUE;
  1123. }
  1125. return FALSE;
  1126. }