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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > Telnet服务器 > 查看源码
FlatHeaderCtrl.cpp
资源名称：(vc).rar　[点击查看]
上传用户：wpp2016
上传日期：2010-02-01
资源大小：1250k
文件大小：32k
源码类别：

Telnet服务器

开发平台：

Visual C++

FlatHeaderCtrl.cpp：源码内容
  1. ////////////////////////////////////////////////////////////////////////////
  2. // File: CFlatHeaderCtrl.cpp
  3. // Version: 1.0.2.0
  4. //
  5. // Author: Maarten Hoeben
  6. // E-mail: hoeben@nwn.com
  7. //
  8. // Implementation of the CFlatHeaderCtrl and associated classes.
  9. //
  10. // You are free to use, distribute or modify this code
  11. // as long as the header is not removed or modified.
  12. //
  13. // Version history
  14. //
  15. // 1.0.0.1 - Initial release
  16. // 1.0.1.0 - Fixed FHDragWnd destroy warning (thanks Philippe Terrier)
  17. // - Fixed double sent HDN_ITEMCLICK
  18. // - Added a property that adjusts for ListCtrls that use a static
  19. //   border for flat look.
  20. // 1.0.2.0 - Fixed another destroy warning
  21. // - Fixed InsertItem array exception handling
  22. // - Fixed incorrect header width painting
  23. // - Changed DrawItem argument passing
  24. // - Changed HDITEMEX struct item names
  25. // - Added handler for HDM_SETIMAGELIST (precalculate image dimensions)
  26. // - Changed DrawImage to clip images
  27. // - Changed InsertItem ASSERT check to position limitation
  28. // - Added new-style "HotDivider" arrows
  29. // - Fixed some GDI objects
  30. // - Added 'don't drop cursor' support to indicate drag&drop 
  31. //   outside control
  32. // - Added drag&drop target window support
  33. // - Changed CFHDragWnd to support externally created items
  34. // - Removed topmost-style from CFHDropWnd
  35. // - Fixed OnSetHotDivider order bug
  36. // - Added extended styles
  37. // - Added item width estimation function
  38. //
  39. ////////////////////////////////////////////////////////////////////////////
  42. // FlatHeaderCtrl.cpp : implementation file
  43. //
  45. #include "stdafx.h"
  46. #include "FlatHeaderCtrl.h"
  48. #ifdef _DEBUG
  49. #define new DEBUG_NEW
  50. #undef THIS_FILE
  51. static char THIS_FILE[] = __FILE__;
  52. #endif
  54. /////////////////////////////////////////////////////////////////////////////
  55. // CFHDragWnd
  57. CFHDragWnd::CFHDragWnd()
  58. {
  59. // Register the window class if it has not already been registered.
  60. WNDCLASS wndclass;
  61. HINSTANCE hInst = AfxGetInstanceHandle();
  63. if(!(::GetClassInfo(hInst, FHDRAGWND_CLASSNAME, &wndclass)))
  64. {
  65. // otherwise we need to register a new class
  66. wndclass.style = CS_SAVEBITS ;
  67. wndclass.lpfnWndProc = ::DefWindowProc;
  68. wndclass.cbClsExtra = wndclass.cbWndExtra = 0;
  69. wndclass.hInstance = hInst;
  70. wndclass.hIcon = NULL;
  71. wndclass.hCursor = LoadCursor( hInst, IDC_ARROW);
  72. wndclass.hbrBackground = (HBRUSH)(COLOR_3DFACE + 1); 
  73. wndclass.lpszMenuName = NULL;
  74. wndclass.lpszClassName = FHDRAGWND_CLASSNAME;
  75. if (!AfxRegisterClass(&wndclass))
  76. AfxThrowResourceException();
  77. }
  79. m_pFlatHeaderCtrl = NULL;
  80. m_iItem = -1;
  81. m_lphdiItem = NULL;
  82. }
  84. CFHDragWnd::~CFHDragWnd()
  85. {
  86. }
  89. BEGIN_MESSAGE_MAP(CFHDragWnd, CWnd)
  90. //{{AFX_MSG_MAP(CFHDragWnd)
  91. ON_WM_PAINT()
  92. ON_WM_ERASEBKGND()
  93. //}}AFX_MSG_MAP
  94. END_MESSAGE_MAP()
  97. /////////////////////////////////////////////////////////////////////////////
  98. // CFHDragWnd message handlers
  100. BOOL CFHDragWnd::Create(CRect rect, CFlatHeaderCtrl* pFlatHeaderCtrl, INT iItem, LPHDITEM lphdiItem)
  101. {
  102. ASSERT_VALID(pFlatHeaderCtrl);
  103. ASSERT(pFlatHeaderCtrl->IsKindOf(RUNTIME_CLASS(CFlatHeaderCtrl)));
  105. m_pFlatHeaderCtrl = pFlatHeaderCtrl;
  106. m_iItem = iItem;
  107. m_lphdiItem = lphdiItem;
  109. DWORD dwStyle = WS_POPUP|WS_DISABLED;
  110. DWORD dwExStyle = WS_EX_TOOLWINDOW|WS_EX_TOPMOST;
  112. return CreateEx(dwExStyle, FHDRAGWND_CLASSNAME, NULL, dwStyle, 
  113. rect.left, rect.top, rect.Width(), rect.Height(),
  114. NULL, NULL, NULL );
  115. }
  118. void CFHDragWnd::OnPaint() 
  119. {
  120. CPaintDC dc(this);
  122.     if(m_pFlatHeaderCtrl->m_bDoubleBuffer)
  123.     {
  124.         CMemDC MemDC(&dc);
  125.         OnDraw(&MemDC);
  126.     }
  127.     else
  128.         OnDraw(&dc);
  129. }
  131. BOOL CFHDragWnd::OnEraseBkgnd(CDC* pDC) 
  132. {
  133. return TRUE;
  134. }
  136. void CFHDragWnd::OnDraw(CDC* pDC)
  137. {
  138. CRect rect;
  139. GetClientRect(rect);
  141.     pDC->FillSolidRect(rect, m_pFlatHeaderCtrl->m_cr3DFace);
  142. pDC->Draw3dRect(rect, m_pFlatHeaderCtrl->m_cr3DHighLight, m_pFlatHeaderCtrl->m_cr3DShadow);
  144. CPen* pPen = pDC->GetCurrentPen();
  145. CFont* pFont = pDC->SelectObject(m_pFlatHeaderCtrl->GetFont());
  147. pDC->SetBkColor(m_pFlatHeaderCtrl->m_cr3DFace);
  148. pDC->SetTextColor(m_pFlatHeaderCtrl->m_crText);
  150. rect.DeflateRect(m_pFlatHeaderCtrl->m_iSpacing, 0);
  151. m_pFlatHeaderCtrl->DrawItem(
  152. pDC,
  153. rect,
  154. m_lphdiItem,
  155. m_pFlatHeaderCtrl->m_iSortColumn == m_iItem,
  156. m_pFlatHeaderCtrl->m_bSortAscending
  157. );
  159. pDC->SelectObject(pFont);
  160. pDC->SelectObject(pPen);
  161. }
  163. void CFHDragWnd::PostNcDestroy() 
  164. {
  165. CWnd::PostNcDestroy();
  166. delete this;
  167. }
  169. /////////////////////////////////////////////////////////////////////////////
  170. // CFHDropWnd
  172. CFHDropWnd::CFHDropWnd(COLORREF crColor)
  173. {
  174. m_brush.CreateSolidBrush(crColor);
  176. // Register the window class if it has not already been registered.
  177. WNDCLASS wndclass;
  178. HINSTANCE hInst = AfxGetInstanceHandle();
  180. if(!(::GetClassInfo(hInst, FHDROPWND_CLASSNAME, &wndclass)))
  181. {
  182. // otherwise we need to register a new class
  183. wndclass.style = CS_SAVEBITS ;
  184. wndclass.lpfnWndProc = ::DefWindowProc;
  185. wndclass.cbClsExtra = wndclass.cbWndExtra = 0;
  186. wndclass.hInstance = hInst;
  187. wndclass.hIcon = NULL;
  188. wndclass.hCursor = LoadCursor( hInst, IDC_ARROW );
  189. wndclass.hbrBackground = (HBRUSH)m_brush; 
  190. wndclass.lpszMenuName = NULL;
  191. wndclass.lpszClassName = FHDROPWND_CLASSNAME;
  192. if (!AfxRegisterClass(&wndclass))
  193. AfxThrowResourceException();
  194. }
  195. }
  197. CFHDropWnd::~CFHDropWnd()
  198. {
  199. }
  202. BEGIN_MESSAGE_MAP(CFHDropWnd, CWnd)
  203. //{{AFX_MSG_MAP(CFHDropWnd)
  204. ON_WM_ERASEBKGND()
  205. //}}AFX_MSG_MAP
  206. END_MESSAGE_MAP()
  209. /////////////////////////////////////////////////////////////////////////////
  210. // CFHDropWnd message handlers
  212. BOOL CFHDropWnd::Create(INT iHeight)
  213. {
  214. m_iHeight = iHeight + 20;
  216. DWORD dwStyle = WS_POPUP|WS_DISABLED;
  217. DWORD dwExStyle = WS_EX_TOOLWINDOW ;
  219. BOOL bResult = CreateEx(dwExStyle, FHDROPWND_CLASSNAME, NULL, dwStyle, 
  220. 0, 0, 12, m_iHeight,
  221. NULL, NULL, NULL );
  223. CRgn rgn1, rgn2;
  224. POINT ptArrow[7];
  226. ptArrow[0].x = 8; ptArrow[0].y = 0;
  227. ptArrow[1].x = 8; ptArrow[1].y = 4;
  228. ptArrow[2].x = 11; ptArrow[2].y = 4;
  229. ptArrow[3].x = 6; ptArrow[3].y = 9;
  230. ptArrow[4].x = 1; ptArrow[4].y = 4;
  231. ptArrow[5].x = 4; ptArrow[5].y = 4;
  232. ptArrow[6].x = 4; ptArrow[6].y = 0;
  233. rgn1.CreatePolygonRgn(ptArrow, 7, ALTERNATE);
  236. ptArrow[0].x = 4; ptArrow[0].y = m_iHeight;
  237. ptArrow[1].x = 4; ptArrow[1].y = m_iHeight-4;
  238. ptArrow[2].x = 0; ptArrow[2].y = m_iHeight-4;
  239. ptArrow[3].x = 6; ptArrow[3].y = m_iHeight-10;
  240. ptArrow[4].x = 12; ptArrow[4].y = m_iHeight-4;
  241. ptArrow[5].x = 8; ptArrow[5].y = m_iHeight-4;
  242. ptArrow[6].x = 8; ptArrow[6].y = m_iHeight;
  243. rgn2.CreatePolygonRgn(ptArrow, 7, ALTERNATE);
  245. m_rgn.CreateRectRgn(0, 0, 12, iHeight);
  246. m_rgn.CombineRgn(&rgn1, &rgn2, RGN_OR);
  247. SetWindowRgn(m_rgn, FALSE);
  249. rgn1.DeleteObject();
  250. rgn2.DeleteObject();
  252. return bResult;
  253. }
  256. void CFHDropWnd::PostNcDestroy() 
  257. {
  258. m_rgn.DeleteObject();
  260. CWnd::PostNcDestroy();
  261. delete this;
  262. }
  264. BOOL CFHDropWnd::OnEraseBkgnd(CDC* pDC) 
  265. {
  266. pDC->FillRect(CRect(0, 0, 12, m_iHeight), &m_brush);
  267. return TRUE;
  268. }
  270. void CFHDropWnd::SetWindowPos(INT x, INT y)
  271. {
  272. CWnd::SetWindowPos(
  273. &wndTop, 
  274. x-6, y-(m_iHeight/2),
  275. 0, 0, SWP_NOSIZE|SWP_SHOWWINDOW|SWP_NOACTIVATE
  276. );
  277. }
  279. /////////////////////////////////////////////////////////////////////////////
  280. // CFlatHeaderCtrl
  282. IMPLEMENT_DYNCREATE(CFlatHeaderCtrl, CHeaderCtrl)
  284. CFlatHeaderCtrl::CFlatHeaderCtrl()
  285. {
  286. m_bDoubleBuffer = TRUE;
  287. m_iSpacing = 6;
  288. m_sizeArrow.cx = 8;
  289. m_sizeArrow.cy = 8;
  290. m_sizeImage.cx = 0;
  291. m_sizeImage.cy = 0;
  292. m_bStaticBorder = FALSE;
  293. m_nDontDropCursor = 0;
  294. m_hDropTarget = NULL;
  295. m_rcDropTarget.SetRectEmpty();
  296. m_iDropResult = 0;
  298. m_iHotIndex = -1;
  299. m_bHotItemResizable = FALSE;
  301. m_bResizing = FALSE;
  303. m_iHotDivider = -1;
  304. m_crHotDivider = 0x000000FF;
  305. m_pDropWnd = NULL;
  307. m_bDragging = FALSE;
  308. m_pDragWnd = NULL;
  310. m_nClickFlags = 0;
  312. m_bSortAscending = FALSE;
  313. m_iSortColumn = -1;
  314. m_arrayHdrItemEx.SetSize(0, 8);
  316. m_cr3DHighLight = ::GetSysColor(COLOR_3DHIGHLIGHT);
  317. m_cr3DShadow = ::GetSysColor(COLOR_3DSHADOW);
  318. m_cr3DFace = ::GetSysColor(COLOR_3DFACE);
  319. m_crText = ::GetSysColor(COLOR_BTNTEXT);
  320. }
  322. CFlatHeaderCtrl::~CFlatHeaderCtrl()
  323. {
  324. if(m_pDropWnd != NULL)
  325. {
  326. m_pDropWnd->DestroyWindow();
  327. m_pDropWnd = NULL;
  328. }
  330. if(m_pDragWnd != NULL)
  331. {
  332. m_pDragWnd->DestroyWindow();
  333. m_pDragWnd = NULL;
  334. }
  335. }
  337. BEGIN_MESSAGE_MAP(CFlatHeaderCtrl, CHeaderCtrl)
  338. //{{AFX_MSG_MAP(CFlatHeaderCtrl)
  339. ON_MESSAGE(HDM_INSERTITEMA, OnInsertItem)
  340. ON_MESSAGE(HDM_INSERTITEMW, OnInsertItem)
  341. ON_MESSAGE(HDM_DELETEITEM, OnDeleteItem)
  342. ON_MESSAGE(HDM_SETIMAGELIST, OnSetImageList)
  343. ON_MESSAGE(HDM_SETHOTDIVIDER, OnSetHotDivider)
  344. ON_MESSAGE(HDM_LAYOUT, OnLayout)
  345. ON_WM_NCHITTEST()
  346. ON_WM_SETCURSOR()
  347. ON_WM_LBUTTONDOWN()
  348. ON_WM_LBUTTONDBLCLK()
  349. ON_WM_PAINT()
  350. ON_WM_SYSCOLORCHANGE()
  351. ON_WM_ERASEBKGND()
  352. ON_WM_LBUTTONUP()
  353. ON_WM_MOUSEMOVE()
  354. //}}AFX_MSG_MAP
  355. END_MESSAGE_MAP()
  357. /////////////////////////////////////////////////////////////////////////////
  358. // CFlatHeaderCtrl attributes
  360. BOOL CFlatHeaderCtrl::ModifyProperty(WPARAM wParam, LPARAM lParam)
  361. {
  362. switch(wParam)
  363. {
  364. case FH_PROPERTY_SPACING:
  365. m_iSpacing = (INT)lParam;
  366. break;
  368. case FH_PROPERTY_ARROW:
  369. m_sizeArrow.cx = LOWORD(lParam);
  370. m_sizeArrow.cy = HIWORD(lParam);
  371. break;
  373. case FH_PROPERTY_STATICBORDER:
  374. m_bStaticBorder = (BOOL)lParam;
  375. break;
  377. case FH_PROPERTY_DONTDROPCURSOR:
  378. m_nDontDropCursor = (UINT)lParam;
  379. break;
  381. case FH_PROPERTY_DROPTARGET:
  382. m_hDropTarget = (HWND)lParam;
  383. break;
  385. default:
  386. return FALSE;
  387. }
  389. Invalidate();
  390. return TRUE;
  391. }
  393. BOOL CFlatHeaderCtrl::GetItemEx(INT iPos, HDITEMEX* phditemex) const
  394. {
  395. if(iPos>=m_arrayHdrItemEx.GetSize())
  396. return FALSE;
  398. *phditemex = m_arrayHdrItemEx[iPos];
  399. return TRUE;
  400. }
  402. BOOL CFlatHeaderCtrl::SetItemEx(INT iPos, HDITEMEX* phditemex)
  403. {
  404. if(iPos>=m_arrayHdrItemEx.GetSize())
  405. return FALSE;
  407. BOOL bUpdate = FALSE;
  409. HDITEM hditem;
  410. hditem.mask = HDI_WIDTH;
  411. if(!GetItem(iPos, &hditem))
  412. return FALSE;
  414. HDITEMEX hditemex = *phditemex;
  416. if(hditemex.nStyle&HDF_EX_AUTOWIDTH)
  417. {
  418. TCHAR szText[FLATHEADER_TEXT_MAX];
  420. HDITEM hdi;
  421. hdi.mask = HDI_WIDTH|HDI_FORMAT|HDI_TEXT|HDI_IMAGE|HDI_BITMAP;
  422. hdi.pszText = szText;
  423. hdi.cchTextMax = sizeof(szText);
  424. VERIFY(GetItem(iPos, &hdi));
  426. hditem.cxy = GetItemWidth(&hdi, hditemex.nStyle&HDF_EX_INCLUDESORT ? TRUE:FALSE);
  427. bUpdate = TRUE;
  428. }
  430. if((!(hditemex.nStyle&HDF_EX_FIXEDWIDTH)) && (hditemex.iMinWidth<=hditemex.iMaxWidth))
  431. {
  432. if(hditem.cxy < hditemex.iMinWidth)
  433. {
  434. hditem.cxy = hditemex.iMinWidth;
  435. bUpdate = TRUE;
  436. }
  438. if(hditem.cxy > hditemex.iMaxWidth)
  439. {
  440. hditem.cxy = hditemex.iMaxWidth;
  441. bUpdate = TRUE;
  442. }
  443. }
  445. if(bUpdate)
  446. SetItem(iPos, &hditem);
  448. m_arrayHdrItemEx.SetAt(iPos, hditemex);
  449. return TRUE;
  450. }
  452. INT CFlatHeaderCtrl::GetItemWidth(LPHDITEM lphdi, BOOL bIncludeSort)
  453. {
  454. INT iWidth = 0;
  456. CBitmap* pBitmap = NULL;
  457. BITMAP biBitmap;
  458. if(lphdi->fmt&HDF_BITMAP)
  459. {
  460. ASSERT(lphdi->mask&HDI_BITMAP);
  461. ASSERT(lphdi->hbm);
  463. pBitmap = CBitmap::FromHandle(lphdi->hbm);
  464. if(pBitmap)
  465. VERIFY(pBitmap->GetObject(sizeof(BITMAP), &biBitmap));
  466. }
  468. iWidth += m_iSpacing;
  469. iWidth += lphdi->fmt&HDF_IMAGE ? m_sizeImage.cx+m_iSpacing:0;
  470. iWidth += lphdi->fmt&HDF_BITMAP ? biBitmap.bmWidth+m_iSpacing:0;
  471. iWidth += bIncludeSort ? m_sizeArrow.cx+m_iSpacing:0;
  473. if(lphdi->mask&HDI_TEXT && lphdi->fmt&HDF_STRING)
  474. {
  475. CClientDC dc(this);
  476. CFont* pFont = dc.SelectObject(GetFont());
  478. iWidth += dc.GetTextExtent(lphdi->pszText).cx + m_iSpacing;
  480. dc.SelectObject(pFont);
  481. }
  483. return iWidth;
  484. }
  486. void CFlatHeaderCtrl::SetSortColumn(INT iPos, BOOL bSortAscending)
  487. {
  488. ASSERT(iPos < GetItemCount());
  490. m_bSortAscending = bSortAscending;
  491. m_iSortColumn = iPos;
  492. Invalidate();
  493. }
  495. INT CFlatHeaderCtrl::GetSortColumn(BOOL* pbSortAscending)
  496. {
  497. if(pbSortAscending)
  498. *pbSortAscending = m_bSortAscending;
  500. return m_iSortColumn;
  501. }
  503. INT CFlatHeaderCtrl::GetDropResult()
  504. {
  505. return m_iDropResult;
  506. }
  508. /////////////////////////////////////////////////////////////////////////////
  509. // CFlatHeaderCtrl implementation
  511. void CFlatHeaderCtrl::DrawCtrl(CDC* pDC)
  512. {
  513. CRect rectClip;
  514. if (pDC->GetClipBox(&rectClip) == ERROR)
  515. return;
  517. CRect rectClient, rectItem;
  518. GetClientRect(&rectClient);
  520.     pDC->FillSolidRect(rectClip, m_cr3DFace);
  522. INT iItems = GetItemCount();
  523. ASSERT(iItems >= 0);
  525. CPen penHighLight(PS_SOLID, 1, m_cr3DHighLight);
  526. CPen penShadow(PS_SOLID, 1, m_cr3DShadow);
  527. CPen* pPen = pDC->GetCurrentPen();
  529. CFont* pFont = pDC->SelectObject(GetFont());
  531. pDC->SetBkColor(m_cr3DFace);
  532. pDC->SetTextColor(m_crText);
  534. INT iWidth = 0;
  536. for(INT i=0;i<iItems;i++)
  537. {
  538. INT iItem = OrderToIndex(i);
  540. TCHAR szText[FLATHEADER_TEXT_MAX];
  542. HDITEM hditem;
  543. hditem.mask = HDI_WIDTH|HDI_FORMAT|HDI_TEXT|HDI_IMAGE|HDI_BITMAP;
  544. hditem.pszText = szText;
  545. hditem.cchTextMax = sizeof(szText);
  546. VERIFY(GetItem(iItem, &hditem));
  548. VERIFY(GetItemRect(iItem, rectItem));
  550. if (rectItem.right >= rectClip.left || rectItem.left <= rectClip.right)
  551. {
  552. if(hditem.fmt&HDF_OWNERDRAW)
  553. {
  554. DRAWITEMSTRUCT disItem;
  555. disItem.CtlType = ODT_BUTTON;
  556. disItem.CtlID = GetDlgCtrlID();
  557. disItem.itemID = iItem;
  558. disItem.itemAction = ODA_DRAWENTIRE;
  559. disItem.itemState = 0;
  560. disItem.hwndItem = m_hWnd;
  561. disItem.hDC = pDC->m_hDC;
  562. disItem.rcItem = rectItem;
  563. disItem.itemData = 0;
  565. DrawItem(&disItem);
  566. }
  567. else
  568. {
  569. rectItem.DeflateRect(m_iSpacing, 0);
  570. DrawItem(pDC, rectItem, &hditem, iItem == m_iSortColumn, m_bSortAscending);
  571. rectItem.InflateRect(m_iSpacing, 0);
  573. if(m_nClickFlags&MK_LBUTTON && m_iHotIndex == iItem && m_hdhtiHotItem.flags&HHT_ONHEADER)
  574. pDC->InvertRect(rectItem);
  575. }
  577. if(i < iItems-1)
  578. {
  579. pDC->SelectObject(&penShadow);
  580. pDC->MoveTo(rectItem.right-1, rectItem.top+2);
  581. pDC->LineTo(rectItem.right-1, rectItem.bottom-2);
  583. pDC->SelectObject(&penHighLight);
  584. pDC->MoveTo(rectItem.right, rectItem.top+2);
  585. pDC->LineTo(rectItem.right, rectItem.bottom-2);
  586. }
  587. }
  589. iWidth += hditem.cxy;
  590. }
  592. if(iWidth > 0)
  593. {
  594. rectClient.right = rectClient.left + iWidth;
  595. pDC->Draw3dRect(rectClient, m_cr3DHighLight, m_cr3DShadow);
  596. }
  598. pDC->SelectObject(pFont);
  599. pDC->SelectObject(pPen);
  601. penHighLight.DeleteObject();
  602. penShadow.DeleteObject();
  603. }
  605. void CFlatHeaderCtrl::DrawItem(LPDRAWITEMSTRUCT)
  606. {
  607. ASSERT(FALSE);  // must override for self draw header controls
  608. }
  610. void CFlatHeaderCtrl::DrawItem(CDC* pDC, CRect rect, LPHDITEM lphdi, BOOL bSort, BOOL bSortAscending)
  611. {
  612. ASSERT(lphdi->mask&HDI_FORMAT);
  614. INT iWidth = 0;
  616. CBitmap* pBitmap = NULL;
  617. BITMAP BitmapInfo;
  618. if(lphdi->fmt&HDF_BITMAP)
  619. {
  620. ASSERT(lphdi->mask&HDI_BITMAP);
  621. ASSERT(lphdi->hbm);
  623. pBitmap = CBitmap::FromHandle(lphdi->hbm);
  624. if(pBitmap)
  625. VERIFY(pBitmap->GetObject(sizeof(BITMAP), &BitmapInfo));
  626. }
  628. switch(lphdi->fmt&HDF_JUSTIFYMASK)
  629. {
  630. case HDF_LEFT:
  631. rect.left += (iWidth = DrawImage(pDC, rect, lphdi, FALSE)) ? iWidth+m_iSpacing : 0;
  632. if(lphdi->fmt&HDF_IMAGE && !iWidth)
  633. break;
  634. rect.right -= bSort ? m_iSpacing+m_sizeArrow.cx : 0;
  635. rect.left += (iWidth = DrawText(pDC, rect, lphdi)) ? iWidth+m_iSpacing : 0;
  636. if(bSort)
  637. {
  638. rect.right += m_iSpacing+m_sizeArrow.cx;
  639. rect.left += DrawArrow(pDC, rect, bSortAscending, FALSE)+m_iSpacing;
  640. }
  641. DrawBitmap(pDC, rect, lphdi, pBitmap, &BitmapInfo, TRUE);
  642. break;
  644. case HDF_CENTER:
  645. rect.left += (iWidth = DrawImage(pDC, rect, lphdi, FALSE)) ? iWidth+m_iSpacing : 0;
  646. if(lphdi->fmt&HDF_IMAGE && !iWidth)
  647. break;
  649. rect.left += bSort ? m_iSpacing+m_sizeArrow.cx : 0;
  650. rect.right -= (iWidth=DrawBitmap(pDC, rect, lphdi, pBitmap, &BitmapInfo, TRUE)) ? iWidth+m_iSpacing:0;
  651. if(bSort)
  652. {
  653. rect.left -= m_iSpacing+m_sizeArrow.cx;
  654. rect.right -= DrawArrow(pDC, rect, bSortAscending, TRUE)+2*m_iSpacing;
  655. }
  656. DrawText(pDC, rect, lphdi);
  657. break;
  659. case HDF_RIGHT:
  660. if(!(lphdi->fmt&HDF_BITMAP_ON_RIGHT))
  661. rect.left += (iWidth=DrawBitmap(pDC, rect, lphdi, pBitmap, &BitmapInfo, FALSE)) ? iWidth+m_iSpacing:0;
  663. rect.left += (iWidth = DrawImage(pDC, rect, lphdi, FALSE)) ? iWidth+m_iSpacing : 0;
  664. if(lphdi->fmt&HDF_IMAGE && !iWidth)
  665. break;
  667. rect.left += bSort && (lphdi->fmt&HDF_BITMAP_ON_RIGHT) ? m_iSpacing+m_sizeArrow.cx : 0;
  668. if(lphdi->fmt&HDF_BITMAP_ON_RIGHT)
  669. rect.right -= (iWidth=DrawBitmap(pDC, rect, lphdi, pBitmap, &BitmapInfo, TRUE)) ? iWidth+m_iSpacing:0;
  670. if(bSort)
  671. {
  672. rect.left -= (lphdi->fmt&HDF_BITMAP_ON_RIGHT) ? m_iSpacing+m_sizeArrow.cx:0;
  673. rect.right -= DrawArrow(pDC, rect, bSortAscending, TRUE)+2*m_iSpacing;
  674. }
  675. DrawText(pDC, rect, lphdi);
  676. break;
  677. }
  678. }
  680. INT CFlatHeaderCtrl::DrawImage(CDC* pDC, CRect rect, LPHDITEM lphdi, BOOL bRight)
  681. {
  682. CImageList* pImageList = GetImageList();
  683. INT iWidth = 0;
  685. if(lphdi->mask&HDI_IMAGE && lphdi->fmt&HDF_IMAGE)
  686. {
  687. ASSERT(pImageList);
  688. ASSERT(lphdi->iImage>=0 && lphdi->iImage<pImageList->GetImageCount());
  690. if(rect.Width()>0)
  691. {
  692. POINT point;
  694. point.y = rect.CenterPoint().y - (m_sizeImage.cy>>1);
  696. if(bRight)
  697. point.x = rect.right - m_sizeImage.cx;
  698. else
  699. point.x = rect.left;
  701. SIZE size;
  702. size.cx = rect.Width()<m_sizeImage.cx ? rect.Width():m_sizeImage.cx;
  703. size.cy = m_sizeImage.cy;
  704. pImageList->DrawIndirect(pDC, lphdi->iImage, point, size, CPoint(0, 0));
  706. iWidth = m_sizeImage.cx;
  707. }
  708. }
  710. return iWidth;
  711. }
  713. INT CFlatHeaderCtrl::DrawBitmap(CDC* pDC, CRect rect, LPHDITEM lphdi, CBitmap* pBitmap, BITMAP* pBitmapInfo, BOOL bRight)
  714. {
  715. INT iWidth = 0;
  717. if(pBitmap)
  718. {
  719. iWidth = pBitmapInfo->bmWidth;
  720. if(iWidth<=rect.Width() && rect.Width()>0)
  721. {
  722. POINT point;
  724. point.y = rect.CenterPoint().y - (pBitmapInfo->bmHeight>>1);
  726. if(bRight)
  727. point.x = rect.right - iWidth;
  728. else
  729. point.x = rect.left;
  731. CDC dc;
  732. if(dc.CreateCompatibleDC(pDC) == TRUE) 
  733. {
  734. VERIFY(dc.SelectObject(pBitmap));
  735. iWidth = pDC->BitBlt(
  736. point.x, point.y, 
  737. pBitmapInfo->bmWidth, pBitmapInfo->bmHeight, 
  738. &dc, 
  739. 0, 0, 
  740. SRCCOPY
  741. ) ? iWidth:0;
  742. }
  743. else iWidth = 0;
  744. }
  745. else
  746. iWidth = 0;
  747. }
  749. return iWidth;
  750. }
  752. INT CFlatHeaderCtrl::DrawText(CDC* pDC, CRect rect, LPHDITEM lphdi)
  753. {
  754. CSize size;
  756. if(rect.Width()>0 && lphdi->mask&HDI_TEXT && lphdi->fmt&HDF_STRING)
  757. {
  758. size = pDC->GetTextExtent(lphdi->pszText);
  760. switch(lphdi->fmt&HDF_JUSTIFYMASK)
  761. {
  762. case HDF_LEFT:
  763. case HDF_LEFT|HDF_RTLREADING:
  764. pDC->DrawText(lphdi->pszText, -1, rect, DT_LEFT|DT_END_ELLIPSIS|DT_SINGLELINE|DT_VCENTER);
  765. break;
  766. case HDF_CENTER:
  767. case HDF_CENTER|HDF_RTLREADING:
  768. pDC->DrawText(lphdi->pszText, -1, rect, DT_CENTER|DT_END_ELLIPSIS|DT_SINGLELINE|DT_VCENTER);
  769. break;
  770. case HDF_RIGHT:
  771. case HDF_RIGHT|HDF_RTLREADING:
  772. pDC->DrawText(lphdi->pszText, -1, rect, DT_RIGHT|DT_END_ELLIPSIS|DT_SINGLELINE|DT_VCENTER);
  773. break;
  774. }
  775. }
  777. size.cx = rect.Width()>size.cx ? size.cx:rect.Width();
  778. return size.cx>0 ? size.cx:0;
  779. }
  781. INT CFlatHeaderCtrl::DrawArrow(CDC* pDC, CRect rect, BOOL bSortAscending, BOOL bRight)
  782. {
  783. INT iWidth = 0;
  785. if(rect.Width()>0 && m_sizeArrow.cx<=rect.Width())
  786. {
  787. iWidth = m_sizeArrow.cx;
  789. rect.top += (rect.Height() - m_sizeArrow.cy - 1)>>1;
  790. rect.bottom = rect.top + m_sizeArrow.cy - 1;
  792. rect.left = bRight ? rect.right-m_sizeArrow.cy:rect.left;
  794. // Set up pens to use for drawing the triangle
  795. CPen penLight(PS_SOLID, 1, m_cr3DHighLight);
  796. CPen penShadow(PS_SOLID, 1, m_cr3DShadow);
  797. CPen *pPen = pDC->SelectObject(&penLight);
  799. if(bSortAscending)
  800. {
  801. // Draw triangle pointing upwards
  802. pDC->MoveTo(rect.left + ((m_sizeArrow.cx-1)>>1) + 1, rect.top);
  803. pDC->LineTo(rect.left +  (m_sizeArrow.cx-1), rect.top + m_sizeArrow.cy - 1);
  804. pDC->LineTo(rect.left, rect.top + m_sizeArrow.cy - 1);
  806. pDC->SelectObject(&penShadow);
  807. pDC->MoveTo(rect.left + ((m_sizeArrow.cx-1)>>1), rect.top);
  808. pDC->LineTo(rect.left, rect.top + m_sizeArrow.cy - 1);
  809. }
  810. else
  811. {
  812. // Draw triangle pointing downwards
  813. pDC->MoveTo(rect.left + ((m_sizeArrow.cx-1)>>1)+1, rect.top + m_sizeArrow.cy - 1);
  814. pDC->LineTo(rect.left +  (m_sizeArrow.cx-1), rect.top);
  816. pDC->SelectObject(&penShadow);
  817. pDC->MoveTo(rect.left + ((m_sizeArrow.cx-1)>>1), rect.top + m_sizeArrow.cy - 1);
  818. pDC->LineTo(rect.left, rect.top);
  819. pDC->LineTo(rect.left + m_sizeArrow.cx, rect.top);
  820. }
  822. // Restore the pen
  823. pDC->SelectObject(pPen);
  825. penLight.DeleteObject();
  826. penShadow.DeleteObject();
  827. }
  829. return iWidth;
  830. }
  832. /////////////////////////////////////////////////////////////////////////////
  833. // CHeaderCtrl message handlers
  835. LRESULT CFlatHeaderCtrl::OnInsertItem(WPARAM wParam, LPARAM lParam)
  836. {
  837. HDITEMEX hditemex;
  838. hditemex.iMinWidth = 0;
  839. hditemex.iMaxWidth = -1;
  841. LRESULT lResult = -1;
  843. WORD wItems = m_arrayHdrItemEx.GetSize();
  844. wParam = wParam<=wItems ? wParam:wItems;
  846. try
  847. {
  848. m_arrayHdrItemEx.InsertAt(wParam, hditemex);
  850. lResult = Default();
  851. if(lResult < 0) // Cleanup
  852. m_arrayHdrItemEx.RemoveAt(wParam);
  853. }
  854. catch(CMemoryException* e)
  855. {
  856. e->Delete();
  857. }
  859. return lResult;
  860. }
  862. LRESULT CFlatHeaderCtrl::OnDeleteItem(WPARAM wParam, LPARAM lParam)
  863. {
  864. ASSERT((INT)wParam < m_arrayHdrItemEx.GetSize());
  865. m_arrayHdrItemEx.RemoveAt(wParam);
  867. return Default();
  868. }
  870. LRESULT CFlatHeaderCtrl::OnSetImageList(WPARAM wParam, LPARAM lParam)
  871. {
  872. CImageList* pImageList;
  873. pImageList = CImageList::FromHandle((HIMAGELIST)lParam);
  875. IMAGEINFO info;
  876. if(pImageList->GetImageInfo(0, &info))
  877. {
  878. m_sizeImage.cx = info.rcImage.right - info.rcImage.left;
  879. m_sizeImage.cy = info.rcImage.bottom - info.rcImage.top;
  880. }
  882. return Default();
  883. }
  885. LRESULT CFlatHeaderCtrl::OnSetHotDivider(WPARAM wParam, LPARAM lParam)
  886. {
  887. if(wParam)
  888. {
  889. HDHITTESTINFO hdhti;
  890. hdhti.pt.x = LOWORD(lParam);
  891. hdhti.pt.y = HIWORD(lParam);
  892. ScreenToClient(&hdhti.pt);
  894. INT iHotIndex = SendMessage(HDM_HITTEST, 0, (LPARAM)(&hdhti));
  895. if(iHotIndex >= 0)
  896. {
  897. HDITEM hditem;
  898. hditem.mask = HDI_ORDER;
  899. VERIFY(GetItem(iHotIndex, &hditem));
  900. m_iHotDivider = hditem.iOrder;
  902. CRect rectItem;
  903. VERIFY(GetItemRect(iHotIndex, rectItem));
  904. if(hdhti.pt.x > rectItem.CenterPoint().x)
  905. m_iHotDivider++;
  906. }
  907. else
  908. m_iHotDivider = -1;
  909. }
  910. else
  911. m_iHotDivider = (INT)lParam;
  913. RECT rect;
  914. GetClientRect(&rect);
  916. INT iItems = GetItemCount();
  917. if(m_iHotDivider >= 0 && m_iHotDivider<=iItems+1)
  918. {
  919. if(m_pDropWnd == NULL)
  920. {
  921. m_pDropWnd = new CFHDropWnd(m_crHotDivider);
  922. if(m_pDropWnd)
  923. m_pDropWnd->Create(rect.bottom - rect.top);
  924. }
  926. if(m_pDropWnd != NULL)
  927. {
  928. POINT pt;
  929. pt.y = (rect.bottom-rect.top)/2;
  931. if(m_iHotDivider<iItems)
  932. {
  933. GetItemRect(OrderToIndex(m_iHotDivider), &rect);
  934. pt.x = rect.left - 1;
  935. }
  936. else
  937. {
  938. GetItemRect(OrderToIndex(iItems-1), &rect);
  939. pt.x = rect.right;
  940. }
  942. ClientToScreen(&pt);
  943. m_pDropWnd->SetWindowPos(pt.x, pt.y);
  944. }
  945. }
  946. else
  947. {
  948. if(m_pDropWnd != NULL)
  949. {
  950. m_pDropWnd->DestroyWindow();
  951. m_pDropWnd = NULL;
  952. }
  953. }
  955. return(LRESULT)m_iHotDivider;
  956. }
  958. LRESULT CFlatHeaderCtrl::OnLayout(WPARAM wParam, LPARAM lParam)
  959. {
  960. LPHDLAYOUT lphdlayout = (LPHDLAYOUT)lParam;
  962. if(m_bStaticBorder)
  963. lphdlayout->prc->right += GetSystemMetrics(SM_CXBORDER)*2;
  965. return CHeaderCtrl::DefWindowProc(HDM_LAYOUT, 0, lParam);
  966. }
  968. /////////////////////////////////////////////////////////////////////////////
  969. // CFlatHeaderCtrl message handlers
  971. void CFlatHeaderCtrl::OnSysColorChange() 
  972. {
  973. CHeaderCtrl::OnSysColorChange();
  975. m_cr3DHighLight = ::GetSysColor(COLOR_3DHIGHLIGHT);
  976. m_cr3DShadow = ::GetSysColor(COLOR_3DSHADOW);
  977. m_cr3DFace = ::GetSysColor(COLOR_3DFACE);
  978. m_crText = ::GetSysColor(COLOR_BTNTEXT);
  979. }
  981. BOOL CFlatHeaderCtrl::OnEraseBkgnd(CDC* pDC) 
  982. {
  983. return TRUE;
  984. }
  986. void CFlatHeaderCtrl::OnPaint() 
  987. {
  988.     CPaintDC dc(this);
  990.     if (m_bDoubleBuffer)
  991.     {
  992.         CMemDC MemDC(&dc);
  993.         DrawCtrl(&MemDC);
  994.     }
  995.     else
  996.         DrawCtrl(&dc);
  997. }
  999. UINT CFlatHeaderCtrl::OnNcHitTest(CPoint point) 
  1000. {
  1001. m_hdhtiHotItem.pt = point;
  1002. ScreenToClient(&m_hdhtiHotItem.pt);
  1004. m_iHotIndex = SendMessage(HDM_HITTEST, 0, (LPARAM)(&m_hdhtiHotItem));
  1005. if(m_iHotIndex >= 0)
  1006. {
  1007. HDITEM hditem;
  1008. hditem.mask = HDI_ORDER;
  1009. VERIFY(GetItem(m_iHotIndex, &hditem));
  1010. m_iHotOrder = hditem.iOrder;
  1012. HDITEMEX hditemex;
  1013. if(GetItemEx(m_iHotIndex, &hditemex))
  1014. m_bHotItemResizable = hditemex.nStyle&HDF_EX_FIXEDWIDTH ? FALSE:TRUE;
  1015. }
  1017. return CHeaderCtrl::OnNcHitTest(point);
  1018. }
  1021. BOOL CFlatHeaderCtrl::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message) 
  1022. {
  1023. if(m_iHotIndex>=0 && m_hdhtiHotItem.flags&(HHT_ONDIVIDER|HHT_ONDIVOPEN) && !m_bHotItemResizable)
  1024. {
  1025. SetCursor(AfxGetApp()->LoadStandardCursor(IDC_ARROW));
  1026. return TRUE;
  1027. }
  1029. return CHeaderCtrl::OnSetCursor(pWnd, nHitTest, message);
  1030. }
  1032. void CFlatHeaderCtrl::OnLButtonDown(UINT nFlags, CPoint point) 
  1033. {
  1034. m_nClickFlags = nFlags;
  1035. m_ptClickPoint = point;
  1037. if(m_iHotIndex >= 0)
  1038. {
  1039. m_hdiHotItem.mask = HDI_WIDTH|HDI_FORMAT|HDI_TEXT|HDI_IMAGE|HDI_BITMAP|HDI_ORDER|HDI_LPARAM;
  1040. m_hdiHotItem.pszText = m_szHotItemText;
  1041. m_hdiHotItem.cchTextMax = sizeof(m_szHotItemText);
  1042. VERIFY(GetItem(m_iHotIndex, &m_hdiHotItem));
  1044. if(m_hdhtiHotItem.flags&HHT_ONHEADER)
  1045. {
  1046. RECT rectItem;
  1047. VERIFY(GetItemRect(m_iHotIndex, &rectItem));
  1048. InvalidateRect(&rectItem);
  1049. }
  1051. if(m_hdhtiHotItem.flags&(HHT_ONDIVIDER|HHT_ONDIVOPEN))
  1052. {
  1053. if(!m_bHotItemResizable)
  1054. return;
  1056. HDITEMEX hditemex;
  1057. VERIFY(GetItemEx(m_iHotIndex, &hditemex));
  1059. CRect rectItem;
  1060. GetItemRect(m_iHotIndex, rectItem);
  1061. ClientToScreen(rectItem);
  1063. if(hditemex.iMinWidth <= hditemex.iMaxWidth)
  1064. {
  1065. CRect rectClip;
  1066. GetClipCursor(rectClip);
  1068. POINT point;
  1069. GetCursorPos(&point);
  1071. INT iOffset = point.x - rectItem.right;
  1073. rectClip.left = rectItem.left + hditemex.iMinWidth + iOffset;
  1074. rectClip.right = rectItem.left + hditemex.iMaxWidth + iOffset;
  1076. ClipCursor(rectClip);
  1077. }
  1079. m_bResizing = TRUE;
  1080. }
  1081. }
  1083. CHeaderCtrl::OnLButtonDown(nFlags, point);
  1084. }
  1087. void CFlatHeaderCtrl::OnLButtonDblClk(UINT nFlags, CPoint point) 
  1088. {
  1089. if(m_iHotIndex>=0 && m_hdhtiHotItem.flags&(HHT_ONDIVIDER|HHT_ONDIVOPEN) && !m_bHotItemResizable)
  1090. return;
  1092. CHeaderCtrl::OnLButtonDblClk(nFlags, point);
  1093. }
  1095. void CFlatHeaderCtrl::OnLButtonUp(UINT nFlags, CPoint point) 
  1096. {
  1097. m_nClickFlags = nFlags;
  1098. m_ptClickPoint = point;
  1100. if(m_iHotIndex >= 0)
  1101. {
  1102. CWnd* pWnd = GetParent();
  1104. if(m_hdhtiHotItem.flags&(HHT_ONDIVIDER|HHT_ONDIVOPEN))
  1105. {
  1106. if(m_bResizing)
  1107. {
  1108. ClipCursor(NULL);
  1109. m_bResizing = FALSE;
  1110. }
  1111. }
  1113. if(m_hdhtiHotItem.flags&HHT_ONHEADER)
  1114. {
  1115. if(m_bDragging)
  1116. {
  1117. NMHEADER nmhdr;
  1118. nmhdr.hdr.hwndFrom = m_hWnd;
  1119. nmhdr.hdr.idFrom = GetDlgCtrlID();
  1120. nmhdr.hdr.code = HDN_ENDDRAG;
  1121. nmhdr.iItem = m_iHotIndex;
  1122. nmhdr.iButton = 0;
  1123. nmhdr.pitem = &m_hdiHotItem;
  1124. if(pWnd->SendMessage(WM_NOTIFY, 0, (LPARAM)&nmhdr)==FALSE && m_iHotDivider>=0)
  1125. {
  1126. INT iCount = GetItemCount();
  1127. ASSERT(m_iHotOrder < iCount);
  1128. ASSERT(m_iHotDivider <= iCount);
  1130. LPINT piArray = new INT[iCount*2];
  1131. if(piArray)
  1132. {
  1133. GetOrderArray((LPINT)piArray, iCount);
  1135. for(INT i=0,j=0;i<iCount;i++)
  1136. {
  1137. if(j == m_iHotOrder)
  1138. j++;
  1140. if(
  1141. (m_iHotOrder<m_iHotDivider && i == m_iHotDivider-1) ||
  1142. (m_iHotOrder>=m_iHotDivider && i == m_iHotDivider)
  1143. )
  1144. piArray[iCount+i] = piArray[m_iHotOrder];
  1145. else
  1146. piArray[iCount+i] = piArray[j++];
  1147. }
  1149. SetOrderArray(iCount, (LPINT)&piArray[iCount]);
  1150. delete piArray;
  1151. }
  1152. else
  1153. AfxThrowMemoryException();
  1154. }
  1156. if(m_pDragWnd != NULL)
  1157. {
  1158. m_pDragWnd->DestroyWindow();
  1159. m_pDragWnd = NULL;
  1160. }
  1162. if (GetCapture()->GetSafeHwnd() == GetSafeHwnd())
  1163. ReleaseCapture();
  1165. m_bDragging = FALSE;
  1166. OnSetHotDivider(FALSE, -1);
  1168. Invalidate();
  1169. }
  1170. else
  1171. {
  1172. RECT rectItem;
  1173. VERIFY(GetItemRect(m_iHotIndex, &rectItem));
  1174. InvalidateRect(&rectItem);
  1175. }
  1176. }
  1177. }
  1179. CHeaderCtrl::OnLButtonUp(nFlags, point);
  1180. }
  1182. void CFlatHeaderCtrl::OnMouseMove(UINT nFlags, CPoint point) 
  1183. {
  1184. if(m_nClickFlags&MK_LBUTTON && m_iHotIndex>=0)
  1185. {
  1186. if(m_bResizing)
  1187. CHeaderCtrl::OnMouseMove(nFlags, point);
  1189. if(m_hdhtiHotItem.flags&HHT_ONHEADER)
  1190. {
  1191. if(m_bDragging)
  1192. {
  1193. if(m_pDragWnd != NULL)
  1194. {
  1195. CRect rect;
  1196. m_pDragWnd->GetWindowRect(&rect);
  1198. CPoint pt = point;
  1199. ClientToScreen(&pt);
  1201. pt.Offset(-(rect.Width()>>1), -(rect.Height()>>1));
  1203. m_pDragWnd->SetWindowPos(
  1204. &wndTop, 
  1205. pt.x, pt.y,
  1206. 0, 0, SWP_NOSIZE|SWP_SHOWWINDOW|SWP_NOACTIVATE
  1207. );
  1209. HDHITTESTINFO hdhti;
  1210. hdhti.pt.x = point.x;
  1211. hdhti.pt.y = point.y;
  1213. INT iHotOrder = -1;
  1214. INT iHotIndex = SendMessage(HDM_HITTEST, 0, (LPARAM)(&hdhti));
  1215. if(iHotIndex >= 0)
  1216. {
  1217. HDITEM hditem;
  1218. hditem.mask = HDI_ORDER;
  1219. VERIFY(GetItem(iHotIndex, &hditem));
  1220. iHotOrder = hditem.iOrder;
  1222. CRect rectItem;
  1223. VERIFY(GetItemRect(iHotIndex, rectItem));
  1224. if(hdhti.pt.x > rectItem.CenterPoint().x)
  1225. iHotOrder++;
  1227. SetCursor(AfxGetApp()->LoadStandardCursor(IDC_ARROW));
  1228. m_iDropResult = 0;
  1229. }
  1230. else
  1231. {
  1232. pt = point;
  1233. ClientToScreen(&pt);
  1235. if(!(m_hDropTarget && m_rcDropTarget.PtInRect(pt)))
  1236. {
  1237. if(m_nDontDropCursor)
  1238. SetCursor(AfxGetApp()->LoadCursor(m_nDontDropCursor));
  1239. else
  1240. SetCursor(AfxGetApp()->LoadStandardCursor(IDC_NO));
  1242. m_iDropResult = -1;
  1243. }
  1244. else
  1245. {
  1246. SetCursor(AfxGetApp()->LoadStandardCursor(IDC_ARROW));
  1247. m_iDropResult = 1;
  1248. }
  1249. }
  1251. if(iHotOrder == m_iHotOrder || iHotOrder == m_iHotOrder+1)
  1252. iHotOrder = -1;
  1254. if(iHotOrder != m_iHotDivider)
  1255. OnSetHotDivider(FALSE, iHotOrder);
  1256. }
  1258. return;
  1259. }
  1260. else if(GetStyle()&HDS_DRAGDROP)
  1261. {
  1262. INT iDragCX = GetSystemMetrics(SM_CXDRAG);
  1263. INT iDragCY = GetSystemMetrics(SM_CYDRAG);
  1264. CRect rectDrag(
  1265. m_ptClickPoint.x-iDragCX, m_ptClickPoint.y-iDragCY,
  1266. m_ptClickPoint.x+iDragCX, m_ptClickPoint.y+iDragCY
  1267. );
  1269. if(!rectDrag.PtInRect(point))
  1270. {
  1271. NMHEADER nmhdr;
  1272. nmhdr.hdr.hwndFrom = m_hWnd;
  1273. nmhdr.hdr.idFrom = GetDlgCtrlID();
  1274. nmhdr.hdr.code = HDN_BEGINDRAG;
  1275. nmhdr.iItem = m_iHotIndex;
  1276. nmhdr.iButton = 1;
  1277. nmhdr.pitem = &m_hdiHotItem;
  1279. BOOL bBeginDrag = TRUE;
  1280. CWnd* pWnd = GetParent();
  1281. if(pWnd != NULL)
  1282. bBeginDrag = pWnd->SendMessage(WM_NOTIFY, 0, (LPARAM)&nmhdr)==FALSE ? TRUE:FALSE;
  1284. if(bBeginDrag)
  1285. {
  1286. ASSERT(m_pDragWnd == NULL);
  1287. m_pDragWnd = new CFHDragWnd;
  1288. if(m_pDragWnd)
  1289. {
  1290. CRect rectItem;
  1291. VERIFY(GetItemRect(m_iHotIndex, rectItem));
  1292. ClientToScreen(&rectItem);
  1294. m_pDragWnd->Create(rectItem, this, m_iHotIndex, &m_hdiHotItem);
  1295. }
  1297. BOOL bVisible = FALSE;
  1298. if(m_hDropTarget != NULL)
  1299. {
  1300. bVisible = ::GetWindowLong(m_hDropTarget, GWL_STYLE)&WS_VISIBLE ? TRUE:FALSE;
  1302. HWND hParent = ::GetParent(m_hDropTarget);
  1303. if(hParent)
  1304. bVisible = ::GetWindowLong(hParent, GWL_STYLE)&WS_VISIBLE ? TRUE:FALSE;
  1305. }
  1307. if(m_hDropTarget != NULL && bVisible)
  1308. VERIFY(::GetWindowRect(m_hDropTarget, m_rcDropTarget));
  1309. else
  1310. m_rcDropTarget.SetRectEmpty();
  1311. }
  1313. SetCapture();
  1314. m_bDragging = TRUE;
  1315. }
  1316. }
  1317. }
  1318. }
  1319. }