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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > P2P编程 > 查看源码
GraphWnd.cpp
资源名称：GGBT.rar　[点击查看]
上传用户：lds876
上传日期：2013-05-25
资源大小：567k
文件大小：11k
源码类别：

P2P编程

开发平台：

Visual C++

GraphWnd.cpp：源码内容
  1. // GraphWnd.cpp : implementation file
  2. //
  4. #include "stdafx.h"
  5. #include "testbt.h"
  6. #include "GraphWnd.h"
  8. #include "download.h"
  9. #include "FileDB.h"
  10. #include "MonitorWnd.h"
  12. #ifdef _DEBUG
  13. #define new DEBUG_NEW
  14. #undef THIS_FILE
  15. static char THIS_FILE[] = __FILE__;
  16. #endif
  18. #define SB_LINEDOWN_WHEEL 10
  19. #define SB_LINEUP_WHEEL 11
  20. /////////////////////////////////////////////////////////////////////////////
  21. // CGraphWnd
  23. CGraphWnd::CGraphWnd() : m_size(11, 11)
  24. {
  25. ASSERT(m_size.cx && m_size.cy);
  27. m_clrBackground = RGB(212, 208, 200); //GetSysColor(COLOR_3DFACE);
  28. m_lGridCountV = 0;
  29. m_lGridCountH = 0;
  31. m_lLineCount = 0;
  32. m_lBeginInx = 0;
  34. m_pFileDBItem = 0;
  35. m_pMonitorWnd = 0;
  36. }
  38. CGraphWnd::~CGraphWnd()
  39. {
  40. }
  43. BEGIN_MESSAGE_MAP(CGraphWnd, CWnd)
  44. //{{AFX_MSG_MAP(CGraphWnd)
  45. ON_WM_PAINT()
  46. ON_WM_SIZE()
  47. ON_WM_CREATE()
  48. ON_WM_VSCROLL()
  49. ON_WM_MOUSEWHEEL()
  50. ON_WM_LBUTTONDOWN()
  51. ON_WM_RBUTTONDOWN()
  52. ON_WM_KEYDOWN()
  53. ON_WM_CHAR()
  54. ON_WM_ERASEBKGND()
  55. ON_WM_CONTEXTMENU()
  56. //}}AFX_MSG_MAP
  57. ON_COMMAND_RANGE(ID_MENUITEM_MONITOR_INFORMATION, ID_MENUITEM_MONITOR_LOGS, OnMenuitemMonitorSub)
  58. END_MESSAGE_MAP()
  61. /////////////////////////////////////////////////////////////////////////////
  62. // CGraphWnd message handlers
  64. void CGraphWnd::Monitor(CFileDBItem *pFileDBItem)
  65. {
  66. m_pFileDBItem = pFileDBItem;
  67. // SetContent(vector<long>());
  68. }
  70. void CGraphWnd::ShowGraph(bool bRefreshInfo)
  71. {
  72. vector<long> vItems;
  73. if (m_pFileDBItem )
  74. {
  75. if (m_pFileDBItem->m_pDownload && m_pFileDBItem->m_pDownload->IsDownloading() && 
  76. !m_pFileDBItem->m_pDownload->GetFeedback().IsStorageChecking())
  77. {
  78. m_pFileDBItem->m_pDownload->GetFractions(vItems);
  79. }
  80. else
  81. {
  82. m_pFileDBItem->GetHave(vItems);
  83. if (!vItems.empty())
  84. {
  85. long lCount = vItems.size();
  86. assert(m_pFileDBItem->m_lPieceCount == vItems.size());
  87. }
  88. else
  89. {
  90. for (int i=0; i<m_pFileDBItem->m_lPieceCount; i++)
  91. vItems.push_back(0);
  92. }
  93. }
  94. }
  98. if (bRefreshInfo || vItems.size() != m_vItems.size())
  99. {
  100. SetContent(vItems);
  101. return;
  102. }
  104. //
  105. // Refresh visible and changed items.
  106. //
  107. m_vItems = vItems;
  108. Refresh();
  109. }
  111. void CGraphWnd::SetContent(vector<long> vItems)
  112. {
  113. m_vItems = vItems;
  114. m_lBeginInx = 0;
  116. if (GetSafeHwnd())
  117. {
  118. CRect rc;
  119. GetClientRect(rc);
  120. OnSizeChanged(rc.Width(), rc.Height());
  122. DrawItem();
  123. }
  124. }
  126. BOOL CGraphWnd::CreateEx(CWnd *pParent, CRect rc, long lID, long lParam, CMonitorWnd* pMonitorWnd)
  127. {
  128. m_pMonitorWnd = pMonitorWnd;
  129. return Create(0, 0, WS_CHILD|WS_BORDER|WS_VISIBLE|WS_VSCROLL, rc, pParent, lID);
  130. }
  132. int CGraphWnd::OnCreate(LPCREATESTRUCT lpCreateStruct) 
  133. {
  134. if (CWnd::OnCreate(lpCreateStruct) == -1)
  135. return -1;
  137. BOOL bRet = m_bmp.LoadBitmap(IDB_BITMAP_GRAPH);
  138. ASSERT(bRet);
  140. SetScrollRange(SB_VERT, 0, 100);
  142. return 0;
  143. }
  145. void CGraphWnd::OnSize(UINT nType, int cx, int cy) 
  146. {
  147. // strange onsize, cx and cy be lager than 63555.
  148. if (cy > 10000 || cx > 10000)
  149. return;
  151. OnSizeChanged(cx, cy);
  152. CWnd::OnSize(nType, cx, cy);
  153. }
  155. void CGraphWnd::OnSizeChanged(int cx, int cy) 
  156. {
  157. long lPosOld = m_lBeginInx * m_lGridCountH;
  158. m_lGridCountH = cx/m_size.cx;
  159. m_lGridCountV = cy/m_size.cy;
  161. m_vGrids.clear();
  163. if (m_lGridCountH && m_lGridCountV)
  164. {
  165. // reset grid value.
  166. m_lBeginInx  = lPosOld / m_lGridCountH;
  167. for (int i=0; i<m_lGridCountV*m_lGridCountH; i++)
  168. {
  169. long lVal = -1;
  170. long lInx = m_lBeginInx * m_lGridCountH + i;
  171. if (lInx < m_vItems.size())
  172. lVal = m_vItems[lInx];
  174. m_vGrids.push_back(lVal);
  175. }
  177. // set scroll info.
  178. m_lLineCount = m_vItems.size() / m_lGridCountH;
  179. if (m_vItems.size()% m_lGridCountH)
  180. m_lLineCount ++;
  182. int nScrollMax = 0;
  183. if (m_lGridCountV < m_lLineCount)
  184. nScrollMax = m_lLineCount - m_lGridCountV;
  186. SCROLLINFO si;
  187. si.cbSize = sizeof(SCROLLINFO);
  188. si.fMask = SIF_ALL; // SIF_ALL = SIF_PAGE | SIF_RANGE | SIF_POS;
  189. si.nMin = 0;
  190. si.nMax = m_lLineCount - 1; // nScrollMax;
  191. si.nPage = m_lGridCountV ;//nScrollMax/10;
  192. si.nPos = m_lBeginInx;
  193. si.nTrackPos = 0;
  194.         SetScrollInfo(SB_VERT, &si, FALSE);
  195. }
  196. else
  197. {
  198. SCROLLINFO si;
  199. si.cbSize = sizeof(SCROLLINFO);
  200. si.fMask = SIF_ALL; // SIF_ALL = SIF_PAGE | SIF_RANGE | SIF_POS;
  201. si.nMin = 0;
  202. si.nMax = 0;
  203. si.nPage = 0;
  204. si.nPos = 0;
  205. si.nTrackPos = 0;
  206.         SetScrollInfo(SB_VERT, &si, FALSE); 
  207. }
  208. }
  210. void CGraphWnd::OnPaint() 
  211. {
  212. CPaintDC dc(this); // device context for painting
  213. DrawItem(&dc);
  214. }
  216. void CGraphWnd::DrawItem(CDC *pDC)
  217. {
  218. CClientDC dc(this);
  219. if (!pDC) pDC = &dc;
  221. CRect rc;
  222. GetWindowRect( rc );
  223. rc.OffsetRect(-rc.left, -rc.top);
  224. CMemDC memdc(pDC, &rc);
  225. memdc.SetBkMode(TRANSPARENT);
  226. memdc.FillSolidRect( rc, m_clrBackground);
  228. long lVisibleCount = m_lGridCountV * m_lGridCountH;
  229. for (int i=0; i<lVisibleCount; i++)
  230. {
  231. DrawSubItem(memdc, i);
  232. }
  233. }
  235. void CGraphWnd::Refresh()
  236. {
  237. CClientDC dc(this);
  239. long lInx = m_lBeginInx * m_lGridCountH;
  240. long lVisibleCount = m_lGridCountV * m_lGridCountH;
  241. for (int i=0; i<lVisibleCount; i++)
  242. {
  243. long lVal = -1;
  244. if ((lInx + i) < m_vItems.size())
  245. lVal = m_vItems[lInx +i];
  247. SetSubItem(i, lVal, &dc);
  248. }
  249. }
  251. void CGraphWnd::SetSubItem(long lSubitemInx, long lVal, CDC *pDC)
  252. {
  253. if (m_vGrids[lSubitemInx] == lVal)
  254. return;
  256. m_vGrids[lSubitemInx] = lVal;
  257. DrawSubItem(pDC, lSubitemInx);
  258. }
  260. void CGraphWnd::DrawSubItem(CDC *pDC, long lSubitemInx)
  261. {
  262. assert(lSubitemInx <m_vGrids.size());
  264. if (!m_lGridCountV)
  265. {
  266. ASSERT(FALSE);
  267. return;
  268. }
  270. long x = m_size.cx * ((lSubitemInx) % m_lGridCountH);
  271. long y = m_size.cy * ((lSubitemInx) / m_lGridCountH);
  272. long cx = 9; // m_size.cx - 1;
  273. long cy = 9; // m_size.cy - 1;
  275. if (m_vGrids[lSubitemInx] == -1)
  276. {
  277. CRect rc(x, y, x + m_size.cx, y +m_size.cy);
  278. pDC->FillRect(rc, &CBrush(m_clrBackground));
  279. }
  280. else
  281. {
  282. CDC MemDC; 
  283. MemDC.CreateCompatibleDC(NULL); 
  284. MemDC.SelectObject(&m_bmp); 
  288. COLORREF col = RGB(0, 0, 255);
  289. long lOffset = 0;
  291. if (m_vGrids[lSubitemInx] == 2)
  292. {
  293. lOffset = cx;
  294. col = RGB(255, 0, 0);
  295. }
  296. else if (m_vGrids[lSubitemInx] == 0)
  297. {
  298. lOffset = cx * 2;
  299. col = RGB(180, 180, 180);
  300. }
  302. pDC->BitBlt(x, y, cx, cy, &MemDC, lOffset, 0, SRCCOPY);
  303. // pDC->Draw3dRect(x, y,cx, cy, col, col);
  305. /*
  306. CString str;
  307. str.Format("%d", lInx);
  308. pDC->DrawText(str, CRect(x, y, x + m_size.cx, y + m_size.cy), DT_LEFT);
  309. //*/
  310. }
  311. }
  314. void CGraphWnd::OnVScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar) 
  315. {
  316. if (m_lGridCountV <= 0)
  317. {
  318. assert(false);
  319. return;
  320. }
  321. //*
  322. int nDelta;
  323. int nMaxPos = m_lLineCount - m_lGridCountV;
  325. switch (nSBCode)
  326. {
  327. case SB_LINEDOWN_WHEEL :
  328. {
  329. if (m_lBeginInx >= nMaxPos)
  330. return;
  331. if ((nMaxPos - m_lBeginInx) < 0)
  332. {
  333. assert(false);
  334. return;
  335. }
  336. nDelta = min(3, nMaxPos - m_lBeginInx); //% m_lGridCountV);
  337. }
  338. break;
  340. case SB_LINEUP_WHEEL:
  341. if (m_lBeginInx <= 0)
  342. return;
  343. nDelta = -min(3, m_lBeginInx);
  344. break;
  346. case SB_LINEDOWN:
  347. if (m_lBeginInx >= nMaxPos)
  348. return;
  349. nDelta = min(1, nMaxPos);
  350. break;
  352. case SB_LINEUP:
  353. if (m_lBeginInx <= 0)
  354. return;
  355. nDelta = -min(1, m_lBeginInx);
  356. break;
  358. case SB_PAGEDOWN:
  359. {
  360. if (m_lBeginInx>= nMaxPos) return;
  362. if ((nMaxPos - m_lBeginInx) < 0)
  363. {
  364. assert(false);
  365. return;
  366. }
  368. long lPage = m_lGridCountV;
  369. if (lPage <= 0) lPage = 1;
  370. nDelta = min(lPage, nMaxPos - m_lBeginInx);
  371. // nDelta = min(lPage, m_lGridCountV);
  372. }
  373. break;
  375. case SB_PAGEUP:
  376. {
  377. if (m_lBeginInx <= 0) return;
  378. long lPage = m_lGridCountV;
  379. if (lPage <= 0) lPage = 1;
  381. nDelta = -min(lPage, m_lBeginInx);
  382. }
  383. break;
  385. case SB_THUMBPOSITION:
  386. {
  387. nDelta = (int)nPos - m_lBeginInx;
  388. }
  389. break;
  390. case SB_THUMBTRACK:
  391. {
  392. nDelta = (int)nPos - m_lBeginInx;
  393. }
  394. break;
  396. default:
  397. return;
  398. }
  400. m_lBeginInx += nDelta;
  401. if (m_lBeginInx < 0 || 
  402. (m_lBeginInx >= m_lLineCount && m_lLineCount != 0))
  403. {
  404. assert(false);
  405. m_lBeginInx = 0;
  406. }
  408. SetScrollPos(SB_VERT, m_lBeginInx, TRUE);
  410. // DrawItem();
  411. Refresh();
  413. CWnd::OnVScroll(nSBCode, nPos, pScrollBar);
  414. }
  418. BOOL CGraphWnd::OnMouseWheel(UINT nFlags, short zDelta, CPoint pt) 
  419. {
  420. OnVScroll(zDelta > 0 ? SB_LINEUP_WHEEL : SB_LINEDOWN_WHEEL , 0, 0);
  421. return CWnd::OnMouseWheel(nFlags, zDelta, pt);
  422. }
  424. void CGraphWnd::OnLButtonDown(UINT nFlags, CPoint point) 
  425. {
  426. SetFocus();
  427. CWnd::OnLButtonDown(nFlags, point);
  428. }
  430. void CGraphWnd::OnRButtonDown(UINT nFlags, CPoint point) 
  431. {
  432. SetFocus();
  433. CWnd::OnRButtonDown(nFlags, point);
  434. }
  436. void CGraphWnd::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags) 
  437. {
  438. switch (nChar)
  439. {
  440. case 0x21:
  441. {
  442. OnVScroll(SB_PAGEUP, 0, 0);
  443. }
  444. break;
  445. case 0x22:
  446. {
  447. OnVScroll(SB_PAGEDOWN, 0, 0);
  448. }
  449. break;
  450. }
  451. CWnd::OnKeyDown(nChar, nRepCnt, nFlags);
  452. }
  454. void CGraphWnd::OnChar(UINT nChar, UINT nRepCnt, UINT nFlags) 
  455. {
  457. CWnd::OnChar(nChar, nRepCnt, nFlags);
  458. }
  460. BOOL CGraphWnd::PreTranslateMessage(MSG* pMsg) 
  461. {
  462. if (pMsg->message == WM_KEYDOWN)
  463. {
  464. switch (pMsg->wParam)
  465. {
  466. case VK_UP:
  467. {
  468. OnVScroll(SB_LINEUP, 0, 0);
  469. return true;
  470. }
  471. break;
  472. case VK_DOWN:
  473. {
  474. OnVScroll(SB_LINEDOWN , 0, 0);
  475. return true;
  476. }
  477. case VK_HOME:
  478. {
  479. OnVScroll(SB_THUMBPOSITION, 0, 0);
  480. return true;
  481. }
  482. case VK_END:
  483. {
  484. if (m_lLineCount <= m_lGridCountV)
  485. return true;
  487. OnVScroll(SB_THUMBPOSITION, m_lLineCount - m_lGridCountV, 0);
  488. return true;
  489. }
  490. break;
  491. }
  492. }
  493. return CWnd::PreTranslateMessage(pMsg);
  494. }
  496. BOOL CGraphWnd::OnEraseBkgnd(CDC* pDC) 
  497. {
  498. /*
  499.     CBrush backBrush(RGB(250, 250, 250));
  500.     CBrush* pOldBrush = pDC->SelectObject(&backBrush);
  502. CRect rect;
  503. pDC->GetClipBox(rect);
  504. pDC->PatBlt(rect.left, rect.top, rect.Width(), rect.Height(),
  505.          PATCOPY);
  507.     pDC->SelectObject(pOldBrush);
  508. return TRUE;
  509. //*/
  511. return CWnd::OnEraseBkgnd(pDC);
  512. }
  514. void CGraphWnd::OnContextMenu(CWnd* pWnd, CPoint point) 
  515. {
  516. CRect rc;
  517. GetClientRect(&rc);
  518. ClientToScreen(rc);
  519. if (!rc.PtInRect(point))
  520. {
  521. CWnd::OnContextMenu(pWnd, point);
  522. return;
  523. }
  526. CMenu menu_bar;
  527. menu_bar.CreatePopupMenu();
  529. if (!m_pMonitorWnd)
  530. {
  531. assert(false);
  532. return;
  533. }
  534. m_pMonitorWnd->OnContextQuery(menu_bar);
  536. CPoint posMouse;
  537. GetCursorPos(&posMouse);
  538. menu_bar.TrackPopupMenu(TPM_LEFTALIGN |TPM_RIGHTBUTTON,posMouse.x,posMouse.y,this);
  539. }
  541. void CGraphWnd::OnMenuitemMonitorSub(UINT uID) 
  542. {
  543. if (!m_pMonitorWnd)
  544. {
  545. assert(false);
  546. return;
  547. }
  548. if (uID >= ID_MENUITEM_MONITOR_INFORMATION && 
  549. uID <= ID_MENUITEM_MONITOR_LOGS)
  550. {
  551. m_pMonitorWnd->OnShowNode(uID );
  552. }
  553. }