GraphWnd.cpp
上传用户:lds876
上传日期:2013-05-25
资源大小:567k
文件大小:11k
源码类别:

P2P编程

开发平台:

Visual C++

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