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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 界面编程 > 查看源码
ExtContentExpandWnd.cpp
资源名称：profuis288_freeware.zip　[点击查看]
上传用户：sesekoo
上传日期：2020-07-18
资源大小：21543k
文件大小：30k
源码类别：

界面编程

开发平台：

Visual C++

ExtContentExpandWnd.cpp：源码内容
  1. // This is part of the Professional User Interface Suite library.
  2. // Copyright (C) 2001-2009 FOSS Software, Inc.
  3. // All rights reserved.
  4. //
  5. // http://www.prof-uis.com
  6. // mailto:support@prof-uis.com
  7. //
  8. // This source code can be used, modified and redistributed
  9. // under the terms of the license agreement that is included
  10. // in the Professional User Interface Suite package.
  11. //
  12. // Warranties and Disclaimers:
  13. // THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND
  14. // INCLUDING, BUT NOT LIMITED TO, WARRANTIES OF MERCHANTABILITY,
  15. // FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  16. // IN NO EVENT WILL FOSS SOFTWARE INC. BE LIABLE FOR ANY DIRECT,
  17. // INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES,
  18. // INCLUDING DAMAGES FOR LOSS OF PROFITS, LOSS OR INACCURACY OF DATA,
  19. // INCURRED BY ANY PERSON FROM SUCH PERSON'S USAGE OF THIS SOFTWARE
  20. // EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
  22. #include "stdafx.h"
  24. #if (!defined __EXT_EXTCONTENTEXPANDWND_H)
  25. #include <ExtContentExpandWnd.h>
  26. #endif
  28. #if (!defined __EXT_PAINT_MANAGER_H)
  29. #include <ExtPaintManager.h>
  30. #endif
  32. #if (!defined __EXT_MEMORY_DC_H)
  33. #include <../Src/ExtMemoryDC.h>
  34. #endif
  36. #ifdef _DEBUG
  37. #define new DEBUG_NEW
  38. #undef THIS_FILE
  39. static char THIS_FILE[] = __FILE__;
  40. #endif
  42. /////////////////////////////////////////////////////////////////////////////
  43. // CExtContentExpandWnd
  45. UINT CExtContentExpandWnd::g_nMsgPaintItemContent =
  46. ::RegisterWindowMessage(
  47. _T("CExtContentExpandWnd::g_nMsgPaintItemContent")
  48. );
  50. IMPLEMENT_DYNCREATE( CExtContentExpandWnd, CWnd );
  51. IMPLEMENT_CExtPmBridge_MEMBERS( CExtContentExpandWnd );
  53. CExtContentExpandWnd::CExtContentExpandWnd()
  54. {
  55. _InitMembers();
  56. VERIFY( RegisterContentExpandWndClass() );
  58. PmBridge_Install();
  59. }
  61. CExtContentExpandWnd::~CExtContentExpandWnd()
  62. {
  63. PmBridge_Uninstall();
  64. }
  66. void CExtContentExpandWnd::_InitMembers()
  67. {
  68. m_hFont = NULL;
  69. m_pRODT = NULL;
  70. m_bDirectCreateCall = false;
  71. m_bVerticalMode = false;
  72. m_rcWnd.SetRectEmpty();
  73. m_rcItem.SetRectEmpty();
  74. m_pWndNotify = NULL;
  75. m_dwActivateFlags = __ECWAF_DEFAULT;
  77. if( m_rgnHelperAreas.GetSafeHandle() != NULL )
  78. {
  79. m_rgnHelperAreas.DeleteObject();
  80. ASSERT( m_rgnHelperAreas.GetSafeHandle() == NULL );
  81. }
  82. if( m_rgnWindow.GetSafeHandle() != NULL )
  83. {
  84. m_rgnWindow.DeleteObject();
  85. ASSERT( m_rgnWindow.GetSafeHandle() == NULL );
  86. }
  87. if( m_rgnItem.GetSafeHandle() != NULL )
  88. {
  89. m_rgnItem.DeleteObject();
  90. ASSERT( m_rgnItem.GetSafeHandle() == NULL );
  91. }
  92. if( m_brHelperAreas.GetSafeHandle() != NULL )
  93. {
  94. m_brHelperAreas.DeleteObject();
  95. ASSERT( m_brHelperAreas.GetSafeHandle() == NULL );
  96. }
  97. }
  99. BEGIN_MESSAGE_MAP(CExtContentExpandWnd, CWnd)
  100. //{{AFX_MSG_MAP(CExtContentExpandWnd)
  101. ON_WM_NCCALCSIZE()
  102. ON_WM_ERASEBKGND()
  103. ON_WM_PAINT()
  104. ON_MESSAGE(WM_SETFONT, OnSetFont)
  105. ON_MESSAGE(WM_GETFONT, OnGetFont)
  106. //}}AFX_MSG_MAP
  107. __EXT_MFC_ON_WM_NCHITTEST()
  108. END_MESSAGE_MAP()
  110.  
  111. LRESULT CExtContentExpandWnd::OnSetFont( WPARAM wParam, LPARAM lParam )
  112. {
  113. ASSERT_VALID( this );
  114. HFONT hFont = (HFONT) wParam;
  115. BOOL bRedraw = (BOOL) lParam;
  116. m_hFont = hFont; 
  117.     if( bRedraw )
  118.         Invalidate();
  119. return 0L;
  120. }
  121.   
  122. LRESULT CExtContentExpandWnd::OnGetFont( WPARAM, LPARAM )
  123. {
  124. ASSERT_VALID( this );
  125.     return (LRESULT) m_hFont;
  126. }
  128. bool CExtContentExpandWnd::Activate(
  129. const RECT & rcItem,
  130. CWnd * pWndNotify,
  131. DWORD dwActivateFlags, // = __ECWAF_DEFAULT
  132. COleDropTarget * pODT, // = NULL
  133. CWnd * pWndOtherForODT // = NULL
  134. )
  135. {
  137. /*
  138. dwActivateFlags =
  139. __ECWAF_DEFAULT
  140. | __ECWAF_DRAW_RED_ARROWS
  141. | __ECWAF_DRAW_RED_DOTS
  142. ;
  143. */
  145. /*
  146. dwActivateFlags &= ~__ECWAF_DRAW_ITEM;
  147. RECT & rcItemXX = (RECT &)rcItem;
  148. rcItemXX.right = rcItemXX.left;
  149. //rcItemXX.bottom = rcItemXX.top;
  150. */
  152. ASSERT( (dwActivateFlags & __ECWAF_DRAW_ANY) != 0 );
  153. if( !RegisterContentExpandWndClass() )
  154. {
  155. ASSERT( FALSE );
  156. return false;
  157. }
  159. if( m_pWndNotify != NULL )
  160. {
  161. Deactivate();
  162. }
  163. ASSERT( m_pWndNotify == NULL );
  165. m_pWndNotify = pWndNotify;
  166. ASSERT( m_pWndNotify != NULL );
  167. ASSERT( m_pWndNotify->GetSafeHwnd() != NULL );
  168. ASSERT( ::IsWindow(m_pWndNotify->GetSafeHwnd()) );
  170. m_dwActivateFlags = dwActivateFlags;
  172. m_bDirectCreateCall = true;
  174. m_rcWnd = rcItem;
  175. m_pWndNotify->ClientToScreen( &m_rcWnd );
  176. RecalcLayout();
  177. //ASSERT( m_rgnHelperAreas.GetSafeHandle() != NULL );
  178. ASSERT( m_rgnWindow.GetSafeHandle() != NULL );
  179. //ASSERT( m_rgnItem.GetSafeHandle() != NULL );
  181. if( ! CWnd::CreateEx(
  182. WS_EX_TOPMOST
  183. | ( (m_dwActivateFlags&__ECWAF_TRANSPARENT_WND)
  184. ? WS_EX_TRANSPARENT
  185. : 0
  186. )
  187. , //|WS_EX_NOPARENTNOTIFY
  188. __EXT_CONTENTEXPANDWND_CLASS_NAME,
  189. NULL,
  190. WS_POPUP,
  191. m_rcWnd.left, m_rcWnd.top,
  192. m_rcWnd.Width(), m_rcWnd.Height(),
  193. m_pWndNotify->GetSafeHwnd(),
  194. (HMENU)NULL,
  195. (LPVOID)NULL
  196. )
  197. )
  198. {
  199. ASSERT( FALSE );
  200. Deactivate();
  201. return false;
  202. }
  204. if( !_CreateHelper() )
  205. {
  206. ASSERT( FALSE );
  207. Deactivate();
  208. AfxThrowMemoryException();
  209. }
  211. ASSERT( m_pRODT == NULL );
  212. if( pODT != NULL )
  213. {
  214. m_pRODT =
  215. new CExtRedirectOleDropTarget(
  216. pODT,
  217. pWndOtherForODT, //m_pWndNotify,
  218. this
  219. );
  220. }
  222. ::SetWindowPos(
  223. GetSafeHwnd(),
  224. HWND_TOP,
  225. -1, -1, -1, -1,
  226. SWP_NOACTIVATE
  227. |SWP_NOMOVE|SWP_NOSIZE
  228. |SWP_SHOWWINDOW
  229. //|SWP_NOREDRAW //|SWP_NOSENDCHANGING
  230. |SWP_NOZORDER //|SWP_NOOWNERZORDER
  231. //|SWP_NOCOPYBITS
  232. );
  234. if( (m_dwActivateFlags&__ECWAF_NO_CAPTURE) == 0 )
  235. CExtMouseCaptureSink::SetCapture( GetSafeHwnd() );
  237. return true;
  238. }
  240. void CExtContentExpandWnd::Deactivate()
  241. {
  242. if( GetSafeHwnd() != NULL )
  243. {
  244. ASSERT( ::IsWindow(GetSafeHwnd()) );
  246. //HWND hWndPostInvalidate = NULL;
  247. if( m_dwActivateFlags & __ECWAF_POST_INVALIDATE )
  248. {
  249. HWND hWndPostInvalidate = m_pWndNotify->GetSafeHwnd();
  250. if( ::IsWindow(hWndPostInvalidate) )
  251. ::InvalidateRect(hWndPostInvalidate,NULL,TRUE);
  252. }
  254. // if( GetStyle() & WS_VISIBLE )
  255. // ShowWindow( SW_HIDE );
  256. if( CExtMouseCaptureSink::GetCapture() == GetSafeHwnd() )
  257. CExtMouseCaptureSink::ReleaseCapture();
  259. _FlushOleRedir();
  260. DestroyWindow();
  261. // if( hWndPostInvalidate != NULL
  262. // && ::IsWindow(hWndPostInvalidate)
  263. // )
  264. // {
  265. // ::InvalidateRect(hWndPostInvalidate,NULL,TRUE);
  266. // ::UpdateWindow(hWndPostInvalidate);
  267. // }
  268. } // if( GetSafeHwnd() != NULL )
  270. _InitMembers();
  271. }
  273. void CExtContentExpandWnd::_FlushOleRedir()
  274. {
  275. ASSERT_VALID( this );
  276. if( m_pRODT == NULL )
  277. return;
  278. m_pRODT->Revoke();
  279. delete m_pRODT;
  280. m_pRODT = NULL;
  281. }
  283. bool CExtContentExpandWnd::g_bContentExpandWndClassRegistered = false;
  285. bool CExtContentExpandWnd::RegisterContentExpandWndClass()
  286. {
  287. if( g_bContentExpandWndClassRegistered )
  288. return true;
  289. WNDCLASS _wndClassInfo;
  290. HINSTANCE hInst = ::AfxGetInstanceHandle();
  291. if( ! ::GetClassInfo( hInst, __EXT_CONTENTEXPANDWND_CLASS_NAME, &_wndClassInfo ) )
  292. {
  293. _wndClassInfo.style = CS_GLOBALCLASS|CS_DBLCLKS|CS_SAVEBITS;
  294. _wndClassInfo.lpfnWndProc = ::DefWindowProc;
  295. _wndClassInfo.cbClsExtra = _wndClassInfo.cbWndExtra = 0;
  296. _wndClassInfo.hInstance = hInst;
  297. _wndClassInfo.hIcon = NULL;
  298. _wndClassInfo.hCursor = ::LoadCursor( NULL, IDC_ARROW );
  299. ASSERT( _wndClassInfo.hCursor != NULL );
  300. _wndClassInfo.hbrBackground = NULL; 
  301. _wndClassInfo.lpszMenuName = NULL;
  302. _wndClassInfo.lpszClassName = __EXT_CONTENTEXPANDWND_CLASS_NAME;
  303. if( !::AfxRegisterClass( &_wndClassInfo ) )
  304. {
  305. ASSERT( FALSE );
  306. //AfxThrowResourceException();
  307. return false;
  308. }
  309. }
  310. g_bContentExpandWndClassRegistered = true;
  311. return true;
  312. }
  314. bool CExtContentExpandWnd::_CreateHelper()
  315. {
  316. ASSERT( m_rgnWindow.GetSafeHandle() != NULL );
  317. SetWindowRgn( (HRGN)m_rgnWindow.GetSafeHandle(), FALSE );
  318. return true;
  319. }
  321. void CExtContentExpandWnd::RecalcLayout()
  322. {
  323. ASSERT( (m_dwActivateFlags & __ECWAF_DRAW_ANY) != 0 );
  324. m_rcItem = m_rcWnd;
  325. m_rcItem.OffsetRect( -m_rcItem.TopLeft() );
  327. ASSERT( m_rgnHelperAreas.GetSafeHandle() == NULL );
  328. ASSERT( m_rgnWindow.GetSafeHandle() == NULL );
  329. ASSERT( m_rgnItem.GetSafeHandle() == NULL );
  331. m_bVerticalMode = false;
  333. const int nDotRgnOffsetDX = 1+1;
  334. const int nDotRgnOffsetDY = 1+1;
  335. const int nDotRadius = 2;
  336. const int nDotStepDelta = 8;
  338. if( m_dwActivateFlags & __ECWAF_DRAW_ITEM )
  339. { // if draw used-defined item
  341. if( m_dwActivateFlags & __ECWAF_DRAW_RED_ARROWS )
  342. { // if draw red arrows around item
  343. const int nDiagonalRgnOffsetDX =
  344. 12 // 9 + 1
  345. ;
  346. const int nDiagonalRgnOffsetDY =
  347. 12 // 9 + 1
  348. ;
  349. m_rcWnd.InflateRect(
  350. nDiagonalRgnOffsetDX,
  351. nDiagonalRgnOffsetDY
  352. );
  353. m_rcItem.OffsetRect(
  354. nDiagonalRgnOffsetDX,
  355. nDiagonalRgnOffsetDY
  356. );
  358. // static POINT vArrowTL[] =
  359. // {
  360. // { 3, 0 },
  361. // { 6, 3 },
  362. // { 8, 1 },
  363. // { 8, 8 },
  364. // { 1, 8 },
  365. // { 3, 6 },
  366. // { 0, 3 },
  367. // };
  368. // CRgn rgnArrowTL;
  369. // VERIFY(
  370. // rgnArrowTL.CreatePolygonRgn(
  371. // vArrowTL,
  372. // sizeof(vArrowTL) / sizeof(vArrowTL[0]),
  373. // ALTERNATE
  374. // )
  375. // );
  377. CRgn rgnArrowTL;
  378. CExtPaintManager::g_DockingCaptionGlyphs[
  379. CExtPaintManager::__DCBT_ARROW_PT_RB
  380. ] -> GenerateRgn( rgnArrowTL );
  381. ASSERT( rgnArrowTL.GetSafeHandle() != NULL );
  383. // static POINT vArrowTR[] =
  384. // {
  385. // { 8, 3 },
  386. // { 5, 6 },
  387. // { 7, 8 },
  388. // { 0, 8 },
  389. // { 0, 1 },
  390. // { 2, 3 },
  391. // { 5, 0 },
  392. // };
  393. // CRgn rgnArrowTR;
  394. // VERIFY(
  395. // rgnArrowTR.CreatePolygonRgn(
  396. // vArrowTR,
  397. // sizeof(vArrowTR) / sizeof(vArrowTR[0]),
  398. // ALTERNATE
  399. // )
  400. // );
  401. // rgnArrowTR.OffsetRgn(
  402. // m_rcWnd.Width() - nDiagonalRgnOffsetDX, //m_rcItem.Width() + nDiagonalRgnOffsetDX,
  403. // 0
  404. // );
  406. CRgn rgnArrowTR;
  407. CExtPaintManager::g_DockingCaptionGlyphs[
  408. CExtPaintManager::__DCBT_ARROW_PT_LB
  409. ] -> GenerateRgn( rgnArrowTR );
  410. ASSERT( rgnArrowTR.GetSafeHandle() != NULL );
  411. rgnArrowTR.OffsetRgn(
  412. m_rcWnd.Width() - nDiagonalRgnOffsetDX,
  413. 0
  414. );
  416. // static POINT vArrowBL[] =
  417. // {
  418. // { 0, 5 },
  419. // { 3, 2 },
  420. // { 1, 0 },
  421. // { 8, 0 },
  422. // { 8, 7 },
  423. // { 6, 5 },
  424. // { 3, 8 },
  425. // };
  426. // CRgn rgnArrowBL;
  427. // VERIFY(
  428. // rgnArrowBL.CreatePolygonRgn(
  429. // vArrowBL,
  430. // sizeof(vArrowBL) / sizeof(vArrowBL[0]),
  431. // ALTERNATE
  432. // )
  433. // );
  434. // rgnArrowBL.OffsetRgn(
  435. // 0,
  436. // m_rcWnd.Height() - nDiagonalRgnOffsetDY // m_rcItem.Height() + nDiagonalRgnOffsetDY
  437. // );
  439. CRgn rgnArrowBL;
  440. CExtPaintManager::g_DockingCaptionGlyphs[
  441. CExtPaintManager::__DCBT_ARROW_PT_RT
  442. ] -> GenerateRgn( rgnArrowBL );
  443. ASSERT( rgnArrowBL.GetSafeHandle() != NULL );
  444. rgnArrowBL.OffsetRgn(
  445. 0,
  446. m_rcWnd.Height() - nDiagonalRgnOffsetDY
  447. );
  449. // static POINT vArrowBR[] =
  450. // {
  451. // { 5, 8 },
  452. // { 2, 5 },
  453. // { 0, 7 },
  454. // { 0, 0 },
  455. // { 7, 0 },
  456. // { 5, 2 },
  457. // { 8, 5 },
  458. // };
  459. // CRgn rgnArrowBR;
  460. // VERIFY(
  461. // rgnArrowBR.CreatePolygonRgn(
  462. // vArrowBR,
  463. // sizeof(vArrowBR) / sizeof(vArrowBR[0]),
  464. // ALTERNATE
  465. // )
  466. // );
  467. // rgnArrowBR.OffsetRgn(
  468. // m_rcWnd.Width() - nDiagonalRgnOffsetDX, // m_rcItem.Width() + nDiagonalRgnOffsetDX,
  469. // m_rcWnd.Height() - nDiagonalRgnOffsetDY // m_rcItem.Height() + nDiagonalRgnOffsetDY
  470. // );
  472. CRgn rgnArrowBR;
  473. CExtPaintManager::g_DockingCaptionGlyphs[
  474. CExtPaintManager::__DCBT_ARROW_PT_LT
  475. ] -> GenerateRgn( rgnArrowBR );
  476. ASSERT( rgnArrowBR.GetSafeHandle() != NULL );
  477. rgnArrowBR.OffsetRgn(
  478. m_rcWnd.Width() - nDiagonalRgnOffsetDX,
  479. m_rcWnd.Height() - nDiagonalRgnOffsetDY
  480. );
  483. CRect rcHelperAreas( m_rcWnd );
  484. rcHelperAreas.OffsetRect( -rcHelperAreas.TopLeft() );
  485. VERIFY(
  486. m_rgnHelperAreas.CreateRectRgnIndirect( &rcHelperAreas )
  487. );
  488. CRgn rgnTmp1, rgnTmp2;
  489. VERIFY(
  490. rgnTmp1.CreateRectRgnIndirect( &rcHelperAreas )
  491. );
  492. VERIFY(
  493. rgnTmp2.CreateRectRgnIndirect( &rcHelperAreas )
  494. );
  495. rgnTmp1.CombineRgn(
  496. &rgnArrowTL,
  497. &rgnArrowTR,
  498. RGN_OR
  499. );
  500. ASSERT( rgnTmp1.GetSafeHandle() != NULL );
  501. rgnTmp2.CombineRgn(
  502. &rgnArrowBL,
  503. &rgnArrowBR,
  504. RGN_OR
  505. );
  506. ASSERT( rgnTmp2.GetSafeHandle() != NULL );
  508. m_rgnHelperAreas.CombineRgn(
  509. &rgnTmp1,
  510. &rgnTmp2,
  511. RGN_OR
  512. );
  513. ASSERT( m_rgnHelperAreas.GetSafeHandle() != NULL );
  514. } // if draw red arrows around item
  516. if( m_dwActivateFlags & __ECWAF_DRAW_RED_DOTS )
  517. { // if draw red dots around item
  518. if( (m_dwActivateFlags & __ECWAF_DRAW_RED_ARROWS) == 0 )
  519. {
  520. m_rcWnd.InflateRect(
  521. nDotRgnOffsetDX,
  522. nDotRgnOffsetDY
  523. );
  524. m_rcItem.OffsetRect(
  525. nDotRgnOffsetDX,
  526. nDotRgnOffsetDY
  527. );
  528. } // if( (m_dwActivateFlags & __ECWAF_DRAW_RED_ARROWS) == 0 )
  530. CSize sizeItem = m_rcItem.Size();
  532. CRect rcHelperDots( 0, 0, 0, 0 );
  533. CRgn rgnHelperDots;
  534. VERIFY(
  535. rgnHelperDots.CreateRectRgnIndirect( &rcHelperDots )
  536. );
  538. LONG nDistance = (sizeItem.cx + sizeItem.cy) * 2;
  539. if( nDistance >= nDotStepDelta )
  540. {
  541. for( LONG nx = nDotStepDelta/2; nx < sizeItem.cx; nx += nDotStepDelta )
  542. {
  543. static RECT rcDot = { -nDotRadius, -nDotRadius, nDotRadius, nDotRadius };
  544. CRgn rgnDot1, rgnDot2;
  545. VERIFY( rgnDot1.CreateEllipticRgnIndirect( &rcDot ) );
  546. VERIFY( rgnDot2.CreateEllipticRgnIndirect( &rcDot ) );
  547. rgnDot1.OffsetRgn(
  548. m_rcItem.left + nx,
  549. m_rcItem.top
  550. );
  551. rgnDot2.OffsetRgn(
  552. m_rcItem.left + m_rcItem.Width() - nx,
  553. m_rcItem.bottom
  554. );
  555. rgnHelperDots.CombineRgn(
  556. &rgnHelperDots,
  557. &rgnDot1,
  558. RGN_OR
  559. );
  560. rgnHelperDots.CombineRgn(
  561. &rgnHelperDots,
  562. &rgnDot2,
  563. RGN_OR
  564. );
  565. ASSERT( rgnHelperDots.GetSafeHandle() != NULL );
  566. }
  568. LONG ny =
  569. ( sizeItem.cy % nDotStepDelta ) / 2
  570. ;
  571. for( ; ny < sizeItem.cy; ny += nDotStepDelta )
  572. {
  573. static RECT rcDot = { -nDotRadius, -nDotRadius, nDotRadius, nDotRadius };
  574. CRgn rgnDot1, rgnDot2;
  575. VERIFY( rgnDot1.CreateEllipticRgnIndirect( &rcDot ) );
  576. VERIFY( rgnDot2.CreateEllipticRgnIndirect( &rcDot ) );
  577. rgnDot1.OffsetRgn(
  578. m_rcItem.left,
  579. m_rcItem.top + m_rcItem.Height() - ny
  580. );
  581. rgnDot2.OffsetRgn(
  582. m_rcItem.right,
  583. m_rcItem.top + ny
  584. );
  585. rgnHelperDots.CombineRgn(
  586. &rgnHelperDots,
  587. &rgnDot1,
  588. RGN_OR
  589. );
  590. rgnHelperDots.CombineRgn(
  591. &rgnHelperDots,
  592. &rgnDot2,
  593. RGN_OR
  594. );
  595. ASSERT( rgnHelperDots.GetSafeHandle() != NULL );
  596. } // for( ; ny < sizeItem.cy; ny += nDotStepDelta )
  598. if( rgnHelperDots.GetSafeHandle() != NULL )
  599. {
  600. if( m_rgnHelperAreas.GetSafeHandle() != NULL )
  601. {
  602. m_rgnHelperAreas.CombineRgn(
  603. &m_rgnHelperAreas,
  604. &rgnHelperDots,
  605. RGN_OR
  606. );
  607. ASSERT( m_rgnHelperAreas.GetSafeHandle() != NULL );
  608. } // if( m_rgnHelperAreas.GetSafeHandle() != NULL )
  609. else
  610. {
  611. CRect rcHelperAreas( m_rcWnd );
  612. rcHelperAreas.OffsetRect( -rcHelperAreas.TopLeft() );
  613. VERIFY(
  614. m_rgnHelperAreas.CreateRectRgnIndirect( &rcHelperAreas )
  615. );
  616. m_rgnHelperAreas.CombineRgn(
  617. &rgnHelperDots,
  618. NULL,
  619. RGN_COPY
  620. );
  621. ASSERT( m_rgnHelperAreas.GetSafeHandle() != NULL );
  622. } // else from if( m_rgnHelperAreas.GetSafeHandle() != NULL )
  623. } // if( rgnHelperDots.GetSafeHandle() != NULL )
  625. } // if( nDistance >= nDotStepDelta )
  627. } // if draw red dots around item
  629. VERIFY(
  630. m_rgnItem.CreateRectRgnIndirect( &m_rcItem )
  631. );
  632. VERIFY(
  633. m_rgnWindow.CreateRectRgnIndirect( &m_rcWnd )
  634. );
  635. if( m_rgnHelperAreas.GetSafeHandle() != NULL )
  636. {
  637. m_rgnWindow.CombineRgn(
  638. &m_rgnHelperAreas,
  639. &m_rgnItem,
  640. RGN_OR
  641. );
  642. } // if( m_rgnHelperAreas.GetSafeHandle() != NULL )
  643. else
  644. {
  645. m_rgnWindow.CombineRgn(
  646. &m_rgnItem,
  647. NULL,
  648. RGN_COPY
  649. );
  650. } // else from if( m_rgnHelperAreas.GetSafeHandle() != NULL )
  652. if( m_dwActivateFlags & __ECWAF_TRANSPARENT_ITEM )
  653. {
  654. m_rgnWindow.CombineRgn(
  655. &m_rgnWindow,
  656. &m_rgnItem,
  657. RGN_XOR
  658. );
  659. if( m_rgnHelperAreas.GetSafeHandle() != NULL )
  660. {
  661. m_rgnWindow.CombineRgn(
  662. &m_rgnWindow,
  663. &m_rgnHelperAreas,
  664. RGN_OR
  665. );
  666. } // if( m_rgnHelperAreas.GetSafeHandle() != NULL )
  667. } // if( m_dwActivateFlags & __ECWAF_TRANSPARENT_ITEM )
  669. } // if draw used-defined item
  670. else
  671. { // if NOT draw used-defined item
  672. ASSERT(
  673. m_rcWnd.left == m_rcWnd.right
  674. || m_rcWnd.top == m_rcWnd.bottom
  675. );
  676. if( m_rcWnd.left == m_rcWnd.right )
  677. m_bVerticalMode = true;
  679. CRect rcWndPrev( m_rcWnd );
  681. if( m_bVerticalMode )
  682. {
  683. if( m_dwActivateFlags & __ECWAF_DRAW_RED_ARROWS )
  684. { // if draw red arrows
  685. m_rcWnd.InflateRect( 6, 12 );
  687. // static POINT vArrowTop[] =
  688. // {
  689. // {  8, 0 },
  690. // {  8, 4 },
  691. // { 11, 4 },
  692. // {  6, 9 },
  693. // {  1, 4 },
  694. // {  4, 4 },
  695. // {  4, 0 },
  696. // };
  697. // CRgn rgnArrowTop;
  698. // VERIFY(
  699. // rgnArrowTop.CreatePolygonRgn(
  700. // vArrowTop,
  701. // sizeof(vArrowTop) / sizeof(vArrowTop[0]),
  702. // ALTERNATE
  703. // )
  704. // );
  705. //
  706. // static POINT vArrowBottom[] =
  707. // {
  708. // {  4, 10 },
  709. // {  4,  6 },
  710. // {  0,  6 },
  711. // {  6,  0 },
  712. // { 12,  6 },
  713. // {  8,  6 },
  714. // {  8, 10 },
  715. // };
  716. // CRgn rgnArrowBottom;
  717. // VERIFY(
  718. // rgnArrowBottom.CreatePolygonRgn(
  719. // vArrowBottom,
  720. // sizeof(vArrowBottom) / sizeof(vArrowBottom[0]),
  721. // ALTERNATE
  722. // )
  723. // );
  724. // rgnArrowBottom.OffsetRgn(
  725. // 0,
  726. // m_rcWnd.Height() - 11
  727. // );
  729. CRgn rgnArrowTop, rgnArrowBottom;
  730. CExtPaintManager::g_DockingCaptionGlyphs[
  731. CExtPaintManager::__DCBT_ARROW_PT_DOWN
  732. ] -> GenerateRgn( rgnArrowTop );
  733. ASSERT( rgnArrowTop.GetSafeHandle() != NULL );
  734. CExtPaintManager::g_DockingCaptionGlyphs[
  735. CExtPaintManager::__DCBT_ARROW_PT_UP
  736. ] -> GenerateRgn( rgnArrowBottom );
  737. ASSERT( rgnArrowBottom.GetSafeHandle() != NULL );
  738. rgnArrowBottom.OffsetRgn(
  739. 0,
  740. m_rcWnd.Height() - 11
  741. );
  743. CRect rcHelperAreas( 0, 0, 0, 0 );
  744. VERIFY(
  745. m_rgnHelperAreas.CreateRectRgnIndirect( &rcHelperAreas )
  746. );
  747. m_rgnHelperAreas.CombineRgn(
  748. &rgnArrowTop,
  749. &rgnArrowBottom,
  750. RGN_OR
  751. );
  752. ASSERT( m_rgnHelperAreas.GetSafeHandle() != NULL );
  753. } // if draw red arrows
  755. if( m_dwActivateFlags & __ECWAF_DRAW_RED_DOTS )
  756. { // if draw red dots
  757. if( (m_dwActivateFlags & __ECWAF_DRAW_RED_ARROWS) == 0 )
  758. m_rcWnd.InflateRect(
  759. nDotRgnOffsetDX/2,
  760. 0,
  761. nDotRgnOffsetDX/2 + 1,
  762. 0
  763. );
  765. CSize sizeItem = m_rcItem.Size();
  767. CRect rcHelperDots( 0, 0, 0, 0 );
  768. CRgn rgnHelperDots;
  769. VERIFY(
  770. rgnHelperDots.CreateRectRgnIndirect( &rcHelperDots )
  771. );
  773. LONG nDistance = (sizeItem.cx + sizeItem.cy) * 2;
  774. if( nDistance >= nDotStepDelta )
  775. {
  776. LONG ny =
  777. ( sizeItem.cy % nDotStepDelta ) / 2
  778. ;
  779. for( ; ny < sizeItem.cy; ny += nDotStepDelta )
  780. {
  781. static RECT rcDot = { -nDotRadius, -nDotRadius, nDotRadius, nDotRadius };
  782. CRgn rgnDot1;
  783. VERIFY( rgnDot1.CreateEllipticRgnIndirect( &rcDot ) );
  784. rgnDot1.OffsetRgn(
  785. rcWndPrev.left - m_rcWnd.left + nDotRadius/2,
  786. rcWndPrev.top - m_rcWnd.top + ny
  787. );
  788. rgnHelperDots.CombineRgn(
  789. &rgnHelperDots,
  790. &rgnDot1,
  791. RGN_OR
  792. );
  793. ASSERT( rgnHelperDots.GetSafeHandle() != NULL );
  794. } // for( ; ny < sizeItem.cy; ny += nDotStepDelta )
  795. } // if( nDistance >= nDotStepDelta )
  797. if( rgnHelperDots.GetSafeHandle() != NULL )
  798. {
  799. if( m_rgnHelperAreas.GetSafeHandle() != NULL )
  800. {
  801. m_rgnHelperAreas.CombineRgn(
  802. &m_rgnHelperAreas,
  803. &rgnHelperDots,
  804. RGN_OR
  805. );
  806. ASSERT( m_rgnHelperAreas.GetSafeHandle() != NULL );
  807. } // if( m_rgnHelperAreas.GetSafeHandle() != NULL )
  808. else
  809. {
  810. CRect rcHelperAreas( m_rcWnd );
  811. rcHelperAreas.OffsetRect( -rcHelperAreas.TopLeft() );
  812. VERIFY(
  813. m_rgnHelperAreas.CreateRectRgnIndirect( &rcHelperAreas )
  814. );
  815. m_rgnHelperAreas.CombineRgn(
  816. &rgnHelperDots,
  817. NULL,
  818. RGN_COPY
  819. );
  820. ASSERT( m_rgnHelperAreas.GetSafeHandle() != NULL );
  821. } // else from if( m_rgnHelperAreas.GetSafeHandle() != NULL )
  822. } // if( rgnHelperDots.GetSafeHandle() != NULL )
  824. } // if draw red dots
  825. } // if( m_bVerticalMode )
  826. else
  827. {
  828. if( m_dwActivateFlags & __ECWAF_DRAW_RED_ARROWS )
  829. { // if draw red arrows
  830. m_rcWnd.InflateRect( 12, 6 );
  832. // static POINT vArrowLeft[] =
  833. // {
  834. // { 0,  9 },
  835. // { 4,  9 },
  836. // { 4, 12 },
  837. // { 9,  6 },
  838. // { 4,  0 },
  839. // { 4,  4 },
  840. // { 0,  4 },
  841. // };
  842. // CRgn rgnArrowLeft;
  843. // VERIFY(
  844. // rgnArrowLeft.CreatePolygonRgn(
  845. // vArrowLeft,
  846. // sizeof(vArrowLeft) / sizeof(vArrowLeft[0]),
  847. // ALTERNATE
  848. // )
  849. // );
  850. //
  851. // static POINT vArrowRight[] =
  852. // {
  853. // { 10,  4},
  854. // {  6,  4},
  855. // {  6,  0},
  856. // {  0,  6},
  857. // {  6, 12},
  858. // {  6,  9},
  859. // { 10,  9},
  860. // };
  861. // CRgn rgnArrowRight;
  862. // VERIFY(
  863. // rgnArrowRight.CreatePolygonRgn(
  864. // vArrowRight,
  865. // sizeof(vArrowRight) / sizeof(vArrowRight[0]),
  866. // ALTERNATE
  867. // )
  868. // );
  869. // rgnArrowRight.OffsetRgn(
  870. // m_rcWnd.Width() - 11,
  871. // 0
  872. // );
  874. CRgn rgnArrowLeft, rgnArrowRight;
  875. CExtPaintManager::g_DockingCaptionGlyphs[
  876. CExtPaintManager::__DCBT_ARROW_PT_RIGHT
  877. ] -> GenerateRgn( rgnArrowLeft );
  878. ASSERT( rgnArrowLeft.GetSafeHandle() != NULL );
  879. CExtPaintManager::g_DockingCaptionGlyphs[
  880. CExtPaintManager::__DCBT_ARROW_PT_LEFT
  881. ] -> GenerateRgn( rgnArrowRight );
  882. ASSERT( rgnArrowRight.GetSafeHandle() != NULL );
  883. rgnArrowRight.OffsetRgn(
  884. m_rcWnd.Width() - 11,
  885. 0
  886. );
  888. CRect rcHelperAreas( 0, 0, 0, 0 );
  889. VERIFY(
  890. m_rgnHelperAreas.CreateRectRgnIndirect( &rcHelperAreas )
  891. );
  892. m_rgnHelperAreas.CombineRgn(
  893. &rgnArrowLeft,
  894. &rgnArrowRight,
  895. RGN_OR
  896. );
  897. ASSERT( m_rgnHelperAreas.GetSafeHandle() != NULL );
  898. } // if draw red arrows
  900. if( m_dwActivateFlags & __ECWAF_DRAW_RED_DOTS )
  901. { // if draw red dots
  902. if( (m_dwActivateFlags & __ECWAF_DRAW_RED_ARROWS) == 0 )
  903. m_rcWnd.InflateRect(
  904. 0,
  905. nDotRgnOffsetDY/2,
  906. 0,
  907. nDotRgnOffsetDY/2 + 1
  908. );
  910. CSize sizeItem = m_rcItem.Size();
  912. CRect rcHelperDots( 0, 0, 0, 0 );
  913. CRgn rgnHelperDots;
  914. VERIFY(
  915. rgnHelperDots.CreateRectRgnIndirect( &rcHelperDots )
  916. );
  918. LONG nDistance = (sizeItem.cx + sizeItem.cy) * 2;
  919. if( nDistance >= nDotStepDelta )
  920. {
  921. LONG nx =
  922. ( sizeItem.cx % nDotStepDelta ) / 2
  923. ;
  924. for( ; nx < sizeItem.cx; nx += nDotStepDelta )
  925. {
  926. static RECT rcDot = { -nDotRadius, -nDotRadius, nDotRadius, nDotRadius };
  927. CRgn rgnDot1;
  928. VERIFY( rgnDot1.CreateEllipticRgnIndirect( &rcDot ) );
  929. rgnDot1.OffsetRgn(
  930. rcWndPrev.left - m_rcWnd.left + nx ,
  931. rcWndPrev.top - m_rcWnd.top + nDotRadius/2
  932. );
  933. rgnHelperDots.CombineRgn(
  934. &rgnHelperDots,
  935. &rgnDot1,
  936. RGN_OR
  937. );
  938. ASSERT( rgnHelperDots.GetSafeHandle() != NULL );
  939. } // for( ; nx < sizeItem.cx; nx += nDotStepDelta )
  940. } // if( nDistance >= nDotStepDelta )
  942. if( rgnHelperDots.GetSafeHandle() != NULL )
  943. {
  944. if( m_rgnHelperAreas.GetSafeHandle() != NULL )
  945. {
  946. m_rgnHelperAreas.CombineRgn(
  947. &m_rgnHelperAreas,
  948. &rgnHelperDots,
  949. RGN_OR
  950. );
  951. ASSERT( m_rgnHelperAreas.GetSafeHandle() != NULL );
  952. } // if( m_rgnHelperAreas.GetSafeHandle() != NULL )
  953. else
  954. {
  955. CRect rcHelperAreas( m_rcWnd );
  956. rcHelperAreas.OffsetRect( -rcHelperAreas.TopLeft() );
  957. VERIFY(
  958. m_rgnHelperAreas.CreateRectRgnIndirect( &rcHelperAreas )
  959. );
  960. m_rgnHelperAreas.CombineRgn(
  961. &rgnHelperDots,
  962. NULL,
  963. RGN_COPY
  964. );
  965. ASSERT( m_rgnHelperAreas.GetSafeHandle() != NULL );
  966. } // else from if( m_rgnHelperAreas.GetSafeHandle() != NULL )
  967. } // if( rgnHelperDots.GetSafeHandle() != NULL )
  969. } // if draw red dots
  970. } // else from if( m_bVerticalMode )
  972. ASSERT( m_rgnHelperAreas.GetSafeHandle() != NULL );
  973. VERIFY(
  974. m_rgnWindow.CreateRectRgn( 0, 0, 0, 0 )
  975. );
  976. m_rgnWindow.CombineRgn(
  977. &m_rgnHelperAreas,
  978. NULL,
  979. RGN_COPY
  980. );
  982. } // if NOT draw used-defined item
  984. }
  986. /////////////////////////////////////////////////////////////////////////////
  987. // CExtContentExpandWnd message handlers
  989. void CExtContentExpandWnd::PreSubclassWindow() 
  990. {
  991. CWnd::PreSubclassWindow();
  993. if( m_bDirectCreateCall )
  994. return;
  996. if( !_CreateHelper() )
  997. {
  998. ASSERT( FALSE );
  999. AfxThrowMemoryException();
  1000. } // if( !Create() )
  1001. }
  1003. BOOL CExtContentExpandWnd::PreCreateWindow(CREATESTRUCT& cs) 
  1004. {
  1005. if( ( !RegisterContentExpandWndClass() )
  1006. || ( !CWnd::PreCreateWindow(cs) )
  1007. )
  1008. {
  1009. ASSERT( FALSE );
  1010. return FALSE;
  1011. }
  1013. cs.lpszClass = __EXT_CONTENTEXPANDWND_CLASS_NAME;
  1015. return TRUE;
  1016. }
  1018. UINT CExtContentExpandWnd::OnNcHitTest(CPoint point) 
  1019. {
  1020. // return CWnd::OnNcHitTest(point);
  1021. point;
  1022. return HTCLIENT;
  1023. }
  1025. void CExtContentExpandWnd::OnNcCalcSize(BOOL bCalcValidRects, NCCALCSIZE_PARAMS FAR* lpncsp) 
  1026. {
  1027. // CWnd::OnNcCalcSize(bCalcValidRects, lpncsp);
  1028. bCalcValidRects;
  1029. CRect rcClient( m_rcWnd );
  1030. ::CopyRect(
  1031. &lpncsp->rgrc[0],
  1032. &rcClient
  1033. );
  1034. }
  1036. BOOL CExtContentExpandWnd::OnEraseBkgnd(CDC* pDC) 
  1037. {
  1038. // return CWnd::OnEraseBkgnd(pDC);
  1039. pDC;
  1040. return TRUE;
  1041. }
  1043. void CExtContentExpandWnd::OnPaint() 
  1044. {
  1045. ASSERT( m_pWndNotify != NULL );
  1046. ASSERT( m_pWndNotify->GetSafeHwnd() != NULL );
  1047. ASSERT( ::IsWindow(m_pWndNotify->GetSafeHwnd()) );
  1049. CPaintDC dcPaint(this);
  1051. ASSERT( (m_dwActivateFlags & __ECWAF_DRAW_ANY) != 0 );
  1053. if( m_dwActivateFlags != 0 )
  1054. {
  1056. CRect rcClient;
  1057. GetClientRect( &rcClient );
  1058. DWORD dwMemDcOptions = 0; // CExtMemoryDC::MDCOPT_RTL_COMPATIBILITY;
  1059. dwMemDcOptions |=
  1060. ( m_dwActivateFlags & __ECWAF_DRAW_SOURCE )
  1061. ? CExtMemoryDC::MDCOPT_TO_MEMORY
  1062. : CExtMemoryDC::MDCOPT_DEFAULT
  1063. ;
  1064. CExtMemoryDC dc(
  1065. &dcPaint,
  1066. NULL, // &rcClient,
  1067. dwMemDcOptions
  1068. );
  1069. if( m_dwActivateFlags & __ECWAF_DRAW_SOURCE )
  1070. dc.BitBlt(
  1071. 0, 0, rcClient.Width(), rcClient.Height(),
  1072. &dcPaint,
  1073. 0, 0,
  1074. SRCCOPY
  1075. );
  1077. if( m_dwActivateFlags & __ECWAF_DRAW_ITEM )
  1078. { // if draw used-defined item
  1079. if( (m_dwActivateFlags & __ECWAF_TRANSPARENT_ITEM) == 0 )
  1080. {
  1081. PAINT_ITEM_CONTENT_DATA _picd( dc, m_rcItem );
  1082. if( !_picd.Notify(
  1083. m_pWndNotify->GetSafeHwnd()
  1084. )
  1085. )
  1086. {
  1087. dc.FillSolidRect(
  1088. &rcClient,
  1089. PmBridge_GetPM()->GetColor( COLOR_BTNFACE, this )
  1090. );
  1091. }
  1092. } // if( (m_dwActivateFlags & __ECWAF_TRANSPARENT_ITEM) == 0 )
  1093. } // if draw used-defined item
  1094. else
  1095. { // if NOT draw used-defined item
  1096. } // if NOT draw used-defined item
  1098. if( m_rgnHelperAreas.GetSafeHandle() != NULL )
  1099. {
  1100. if( m_brHelperAreas.GetSafeHandle() == NULL )
  1101. {
  1102. VERIFY(
  1103. m_brHelperAreas.CreateSolidBrush(
  1104. RGB(255,0,0)
  1105. )
  1106. );
  1107. }
  1108. if( m_brHelperAreas.GetSafeHandle() != NULL )
  1109. dc.FillRgn( &m_rgnHelperAreas, &m_brHelperAreas );
  1110. }
  1112. } // if( m_dwActivateFlags != 0 )
  1113. }
  1115. LRESULT CExtContentExpandWnd::WindowProc(UINT message, WPARAM wParam, LPARAM lParam) 
  1116. {
  1117. switch( message )
  1118. {
  1119. case WM_DESTROY:
  1120. _FlushOleRedir();
  1121. break; // case WM_DESTROY:
  1122. } // switch( message )
  1125. if( m_pWndNotify != NULL )
  1126. {
  1127. bool bPassMouseMessage = false;
  1128. switch( message )
  1129. {
  1130. case WM_MOUSEACTIVATE:
  1131. if( ( m_dwActivateFlags & __ECWAF_HANDLE_MOUSE_ACTIVATE ) != 0 )
  1132. {
  1133. switch( ( m_dwActivateFlags & __ECWAF_MA_MASK ) )
  1134. {
  1135. case __ECWAF_MA_ACTIVATE: return MA_ACTIVATE;
  1136. case __ECWAF_MA_ACTIVATEANDEAT: return MA_ACTIVATEANDEAT;
  1137. case __ECWAF_MA_NOACTIVATE: return MA_NOACTIVATE;
  1138. case __ECWAF_MA_NOACTIVATEANDEAT: return MA_NOACTIVATEANDEAT;
  1139. #ifdef _DEBUG
  1140. default:
  1141. ASSERT( FALSE );
  1142. break;
  1143. #endif // _DEBUG
  1144. } // switch( ( m_dwActivateFlags & __ECWAF_MA_MASK ) )
  1145. }
  1146. break;
  1147. case WM_LBUTTONDOWN:
  1148. bPassMouseMessage =
  1149. ( m_dwActivateFlags & __ECWAF_PASS_WM_LBUTTONDOWN )
  1150. ? true : false;
  1151. break;
  1152. case WM_MBUTTONDOWN:
  1153. bPassMouseMessage =
  1154. ( m_dwActivateFlags & __ECWAF_PASS_WM_MBUTTONDOWN )
  1155. ? true : false;
  1156. break;
  1157. case WM_RBUTTONDOWN:
  1158. bPassMouseMessage =
  1159. ( m_dwActivateFlags & __ECWAF_PASS_WM_RBUTTONDOWN )
  1160. ? true : false;
  1161. break;
  1162. case WM_LBUTTONUP:
  1163. bPassMouseMessage =
  1164. ( m_dwActivateFlags & __ECWAF_PASS_WM_LBUTTONUP )
  1165. ? true : false;
  1166. break;
  1167. case WM_MBUTTONUP:
  1168. bPassMouseMessage =
  1169. ( m_dwActivateFlags & __ECWAF_PASS_WM_MBUTTONUP )
  1170. ? true : false;
  1171. break;
  1172. case WM_RBUTTONUP:
  1173. bPassMouseMessage =
  1174. ( m_dwActivateFlags & __ECWAF_PASS_WM_RBUTTONUP )
  1175. ? true : false;
  1176. break;
  1177. case WM_LBUTTONDBLCLK:
  1178. bPassMouseMessage =
  1179. ( m_dwActivateFlags & __ECWAF_PASS_WM_LBUTTONDBLCLK )
  1180. ? true : false;
  1181. break;
  1182. case WM_MBUTTONDBLCLK:
  1183. bPassMouseMessage =
  1184. ( m_dwActivateFlags & __ECWAF_PASS_WM_MBUTTONDBLCLK )
  1185. ? true : false;
  1186. break;
  1187. case WM_RBUTTONDBLCLK:
  1188. bPassMouseMessage =
  1189. ( m_dwActivateFlags & __ECWAF_PASS_WM_RBUTTONDBLCLK )
  1190. ? true : false;
  1191. break;
  1192. case WM_MOUSEWHEEL:
  1193. bPassMouseMessage =
  1194. ( m_dwActivateFlags & __ECWAF_PASS_WM_MOUSEWHEEL )
  1195. ? true : false;
  1196. break;
  1197. case WM_MOUSEMOVE:
  1198. bPassMouseMessage =
  1199. ( m_dwActivateFlags & __ECWAF_PASS_WM_MOUSEMOVE )
  1200. ? true : false;
  1201. break;
  1202. } // switch( message )
  1203. if( bPassMouseMessage )
  1204. {
  1205. CPoint ptCursor( 0, 0 );
  1206. ::GetCursorPos( &ptCursor );
  1207. m_pWndNotify->ScreenToClient( &ptCursor );
  1208. lParam = MAKELPARAM( ptCursor.x, ptCursor.y );
  1209. LRESULT lResult =
  1210. ::SendMessage(
  1211. m_pWndNotify->GetSafeHwnd(),
  1212. message,
  1213. wParam,
  1214. lParam
  1215. );
  1216. if( (m_dwActivateFlags&__ECWAF_REDIRECT_NO_DEACTIVATE) == 0 )
  1217. Deactivate();
  1218. if( (m_dwActivateFlags&__ECWAF_REDIRECT_AND_HANDLE) == 0 )
  1219. {
  1220. if( (m_dwActivateFlags&__ECWAF_REDIRECT_RETVAL) != 0 )
  1221. return lResult;
  1222. return 0;
  1223. } // if( (m_dwActivateFlags&__ECWAF_REDIRECT_AND_HANDLE) == 0 )
  1224. } // if( bPassMouseMessage )
  1225. } // if( m_pWndNotify != NULL )
  1227. return CWnd::WindowProc(message, wParam, lParam);
  1228. }