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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > SNMP编程 > 查看源码
SHEETREPORT.CPP
资源名称：SNMP_source.rar　[点击查看]
上传用户：lvjun8202
上传日期：2013-04-30
资源大小：797k
文件大小：19k
源码类别：

SNMP编程

开发平台：

C/C++

SHEETREPORT.CPP：源码内容
  1. /************************************
  2.   REVISION LOG ENTRY
  3.   Revision By: Mihai Filimon
  4.   Revised on 7/21/98 10:12:24 AM
  5.   Comments: SheetAlpha.cpp: implementation of the CSheetReport class.
  6.  ************************************/
  8. #include "stdafx.h"
  9. #include "SheetReport.h"
  12. //////////////////////////////////////////////////////////////////////
  13. // Construction/Destruction
  14. //////////////////////////////////////////////////////////////////////
  19. #define IDTIMERWAITTODRAG 1000
  20. #define WAITTODRAG 500
  21. #define IDTIMERSCROLL 1001
  22. #define IDTIMERSPLASH 1002
  23. #define WAITSCROLL 10
  26. BEGIN_MESSAGE_MAP(CSheetReport, CSheetsWnd)
  27. //{{AFX_MSG_MAP(CSheetReport)
  28. ON_WM_LBUTTONDOWN()
  29. ON_WM_CREATE()
  30. ON_WM_HSCROLL()
  31. ON_WM_MOUSEMOVE()
  32. ON_WM_LBUTTONUP()
  33. ON_WM_SETCURSOR()
  34. ON_WM_TIMER()
  35. //}}AFX_MSG_MAP
  36. END_MESSAGE_MAP()
  38. // Function name : CSheetReport::CSheetReport
  39. // Description     : Default constructor of object
  40. // Return type : 
  41. CSheetReport::CSheetReport()
  42. {
  43. m_nActive = -1;
  44. m_fDXScrollBar = (double)2 / 5;
  45. m_nDXSplitter = 5;
  46. m_bCaptured = FALSE;
  47. }
  49. // Function name : CSheetReport::~CSheetReport
  50. // Description     : Destructor of this object
  51. // Return type : 
  52. CSheetReport::~CSheetReport()
  53. {
  54. int nCount = m_arrViews.GetSize();
  55. for (int i = 0; i < nCount; i++)
  56. delete m_arrViews.GetAt(i);
  57. m_arrViews.RemoveAll();
  59. }
  61. // Function name : CSheetReport::GetFirstView overridable
  62. // Description     : See CSheetsWnd::GetFirstView
  63. // Return type : CWnd* 
  64. CWnd* CSheetReport::GetFirstView()
  65. {
  66. m_nFind = -1;
  67. return GetNextView();
  68. }
  70. // Function name : CSheetReport::GetNextView overridable
  71. // Description     : See CSheetsWnd::GetNextView
  72. // Return type : CWnd* 
  73. CWnd* CSheetReport::GetNextView()
  74. {
  75. if (++m_nFind < m_arrViews.GetSize())
  76. return m_arrViews[m_nFind];
  77. return NULL;
  78. }
  80. // Function name : CSheetReport::GetActiveView overridable
  81. // Description     : See: CSheetsWnd::GetActiveView
  82. // Return type : CWnd* 
  83. CWnd* CSheetReport::GetActiveView()
  84. {
  85. if ((m_nActive>=0) && (m_nActive < m_arrViews.GetSize()))
  86. {
  87. m_nFind = m_nActive;
  88. return m_arrViews[m_nActive];
  89. }
  90. return NULL;
  91. }
  93. // Function name : CSheetReport::SetActiveView
  94. // Description     : Sets the active view
  95. // Return type : void 
  96. // Argument         : CWnd* pView
  97. void CSheetReport::SetActiveView(CWnd* pView)
  98. {
  99. // CSheetsWnd::SetActiveView(pView);
  100. CWnd* pOldActiveView = GetActiveView(), *pParent = GetParent();
  101. if (pView)
  102. if (pView != pOldActiveView)
  103. {
  104. // pParent->SendMessage(GetMessagePageChanging(), (WPARAM)pOldActiveView, (LPARAM)pView);
  105. if (!pOldActiveView || (pOldActiveView && pOldActiveView->m_hWnd != pView->m_hWnd))
  106. {
  107. pView->ShowWindow(SW_SHOW);
  108. if (pOldActiveView)
  109. pOldActiveView->ShowWindow(SW_HIDE);
  110. // Invalidate();
  111. // pParent->SendMessage(GetMessagePageChanged(), (WPARAM)pView, 0);
  112. }
  113. ((COutputReport *)pView)->m_nHasAlert = 0;
  114. // ((COutputReport *)pView)->SetSel();
  115. }
  116. if (pView)
  117. {
  118. CWnd* pParent = GetParent();
  119. int n = GetPageIndex(pView);
  120. pParent->SendMessage(GetMessagePageChanging(), (WPARAM)GetActiveView(), (LPARAM)pView);
  121. {
  122. if (n != m_nActive)
  123. {
  124. m_nActive = n;
  125. Invalidate();
  126. pParent->SendMessage(GetMessagePageChanged(), (WPARAM)pView, 0);
  127. }
  128. }
  129. }
  130. }
  132. // Function name : CSheetReport::GetViewTitle overridable
  133. // Description     : See CSheetsWnd::GetViewTitle
  134. // Return type : CString 
  135. // Argument         : CWnd* pView
  136. CString CSheetReport::GetViewTitle(CWnd* pView)
  137. {
  138. CString result = ((COutputReport*) pView)->m_strName;
  139. if (result.IsEmpty())
  140. result = _T("Sheet");
  141. return result;
  142. // return CSheetsWnd::GetViewTitle(pView);
  143. }
  145. // Function name : CSheetReport::OnLButtonDown
  146. // Description     : When user click in one of the pages..., it's different by CSheetsWnd::OnLButtonDown,
  147. // because in that object pages are not childs of parent object!
  148. // Return type : void 
  149. // Argument         : UINT nFlags
  150. // Argument         : CPoint point
  151. void CSheetReport::OnLButtonDown(UINT nFlags, CPoint point) 
  152. {
  153. SetFocus();
  154. if (GetSplitterRect().PtInRect(point))
  155. {
  156. m_bPointCaptured = point;
  157. m_bCaptured = TRUE;
  158. SetCapture();
  159. }
  161. BeginDrag(point);
  163. CSheetsWnd::OnLButtonDown (nFlags, point);
  164. }
  166. // Function name : CSheetReport::OnMouseMove
  167. // Description     : When user move mouse and drag the splitter...
  168. // Return type : void 
  169. // Argument         : UINT nFlags
  170. // Argument         : CPoint point
  171. void CSheetReport::OnMouseMove(UINT nFlags, CPoint point) 
  172. {
  173. if (m_bCaptured)
  174. {
  175. CRect rect; GetClientRect(rect);
  176. m_fDXScrollBar = 1 - (double)point.x / rect.Width();
  177. Resize(GetParent()->m_hWnd);
  178. Invalidate();
  179. }
  181. TrackDrag(point);
  183. CSheetsWnd::OnMouseMove(nFlags, point);
  184. }
  186. // Function name : CSheetReport::OnLButtonUp
  187. // Description     : Release the capture if object is captured. Remember spliter
  188. // Return type : void 
  189. // Argument         : UINT nFlags
  190. // Argument         : CPoint point
  191. void CSheetReport::OnLButtonUp(UINT nFlags, CPoint point) 
  192. {
  193. if (m_bCaptured)
  194. {
  195. m_bCaptured = FALSE;
  196. ReleaseCapture();
  197. }
  199. EndDrag(point);
  201. CSheetsWnd::OnLButtonUp(nFlags, point);
  202. }
  204. // Function name : CSheetReport::OnSetCursor
  205. // Description     : When user scan splitter rect must be LR cursor.
  206. // Return type : BOOL 
  207. // Argument         : CWnd* pWnd
  208. // Argument         : UINT nHitTest
  209. // Argument         : UINT message
  210. BOOL CSheetReport::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message) 
  211. {
  212. CPoint p;
  213. if (GetCursorPos(&p))
  214. {
  215. ScreenToClient(&p);
  216. if (GetSplitterRect().PtInRect(p))
  217. if (!m_sPageDrag.IsDragging())
  218. {
  219. ::SetCursor(AfxGetApp()->LoadStandardCursor(IDC_SIZEWE));
  220. return TRUE;
  221. }
  222. }
  224. return CSheetsWnd::OnSetCursor(pWnd, nHitTest, message);
  225. }
  227. // Function name : CSheetReport::RecalcDrawRect
  228. // Description     : If something occurs in that object, like scroll bar, splitter then
  229. // m_DrawRect member variable, must be overwrite, for painting message.
  230. // Return type : void 
  231. void CSheetReport::RecalcDrawRect()
  232. {
  233. CRect rect; GetClientRect(rect);
  234. if (m_sbHorz.IsWindowVisible())
  235. {
  236. m_sbHorz.GetWindowRect(rect);
  237. ScreenToClient(rect);
  238. rect.right = rect.left;
  239. }
  240. m_DrawRect.right = rect.right - (bSplitter() ? m_nDXSplitter : 0);
  241. }
  243. // Function name : CSheetReport::Resize
  244. // Description     : Do not call base Resize, because it's not the same situation
  245. // Return type : void 
  246. // Argument         : HWND hWndParent
  247. void CSheetReport::Resize(HWND hWndParent)
  248. {
  250. CRect rect = GetRect(hWndParent);
  251. MoveWindow(rect);
  253. rect.bottom = rect.top;
  254. rect.top = 0;
  256. int nIndex = 0;
  257. CWnd* pChild;// = GetFirstView();
  258. while (nIndex<m_arrViews.GetSize())
  259. {
  260. pChild = m_arrViews[nIndex];
  261. pChild->MoveWindow(rect);
  262. nIndex++;
  263. }
  266. GetWindowRect(rect);
  267. ScreenToClient(rect);
  268. CRect rectBtns; m_btns.GetWindowRect(rectBtns);
  269. ScreenToClient(rectBtns);
  270. rect.left = min(max(rectBtns.right + GetSplitterRect().Width(), rect.right - (int)((double)rect.Width() * m_fDXScrollBar)), rect.Width() - 8);
  271. m_sbHorz.MoveWindow(rect);
  272. RecalcDrawRect();
  273. Invalidate();
  274. }
  276. // Function name : CSheetReport::OnCreate
  277. // Description     : Create a new scrollbar, for substitute an just in case that parent object 
  278. // need a horizontal scroll bar
  279. // Return type : int 
  280. // Argument         : LPCREATESTRUCT lpCreateStruct
  281. int CSheetReport::OnCreate(LPCREATESTRUCT lpCreateStruct) 
  282. {
  283. if (CSheetsWnd::OnCreate(lpCreateStruct) == -1)
  284. return -1;
  286. m_sbHorz.Create(WS_CHILD | SBS_HORZ, CRect(0,0,0,0), this, IDBTNS + 1);
  288. SetTimer(IDTIMERSPLASH,1000,NULL);
  289. return 0;
  290. }
  292. // Function name : CSheetReport::Draw
  293. // Description     : Draw the pages of object, like CSheetsWnd::Draw() and complete the image of splitter.
  294. // Return type : void 
  295. // Argument         : CDC * pDC
  296. void CSheetReport::Draw(CDC * pDC)
  297. {
  298. CSheetsWnd::Draw(pDC);
  299. CRect rSplitter = GetSplitterRect();
  300. if (!rSplitter.IsRectEmpty())
  301. {
  302. pDC->FillRect(rSplitter, &CBrush(RGB(192,192,192)));
  303. static CPen pWhite(PS_SOLID,1,RGB(255,255,255));
  304. static CPen  pGray(PS_SOLID,1,RGB(128,128,128));
  305. pDC->SelectObject(&pGray);
  306. CPoint p = rSplitter.TopLeft() + CPoint(1,1);
  307. p += CPoint(2,0);
  308. pDC->MoveTo(p);
  309. p += CPoint(0,rSplitter.Height() - 2);
  310. pDC->LineTo(p);
  311. p += CPoint(-2,0);
  312. pDC->LineTo(p);
  313. pDC->SelectObject(&pWhite);
  314. p += CPoint(0,-(rSplitter.Height() - 2));
  315. pDC->LineTo(p);
  316. p += CPoint(2,0);
  317. pDC->LineTo(p);
  318. }
  319. }
  321. // Function name : CSheetReport::ShowScrollBar
  322. // Description     : Show or hide the scroll bar.m_sbHorz
  323. // Return type : void 
  324. // Argument         : BOOL bShow
  325. void CSheetReport::ShowScrollBar(BOOL bShow)
  326. {
  327. m_sbHorz.ShowWindow(bShow ? SW_SHOW : SW_HIDE);
  328. RecalcDrawRect();
  329. Invalidate();
  330. }
  332. // Function name : CSheetReport::OnHScroll
  333. // Description     : If the control receive a scroll message from m_sbHorz, then treat this
  334. // Return type : void 
  335. // Argument         : UINT nSBCode
  336. // Argument         : UINT nPos
  337. // Argument         : CScrollBar* pScrollBar
  338. void CSheetReport::OnHScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar) 
  339. {
  340. if (pScrollBar->m_hWnd == m_sbHorz.m_hWnd)
  341. {
  342. CWnd* pParent = GetActiveView();
  343. ASSERT (pParent && GetParent()->m_hWnd);
  344. switch (nSBCode)
  345. {
  346. case SB_THUMBTRACK:
  347. {
  348. int npp = m_sbHorz.GetScrollPos();
  349. int n = nPos - npp;
  350. UINT nCode = n < 0 ? SB_LINELEFT : SB_LINERIGHT;
  351. int nStep = n < 0 ? -1 : 1;
  352. n = abs(n);
  353. for (int i = 0; i < n; i++ )
  354. {
  355. pParent->SendMessage(WM_HSCROLL, MAKELONG(nCode,1), (long)pScrollBar->m_hWnd);
  356. npp = npp + nStep;
  357. m_sbHorz.SetScrollPos(npp);
  358. }
  359. break;
  360. }
  361. default:
  362. {
  363. pParent->SendMessage(WM_HSCROLL, MAKELONG(nSBCode,nPos), (long)pScrollBar->m_hWnd);
  365. int x = m_sbHorz.GetScrollPos();
  366. int min = 0;
  367. int max = 1024;
  368. int page = 10;
  369. CWnd * pWnd = GetActiveView();
  370. if(pWnd && pWnd->GetSafeHwnd())
  371. {
  372. pWnd->GetScrollRange(SB_HORZ,&min,&max);
  373. CRect rc;
  374. pWnd->GetClientRect(&rc);
  375. page = rc.Width();
  376. }
  379. switch (nSBCode)
  380. {
  381. case SB_TOP:
  382. x = 0;
  383. break;
  384. case SB_BOTTOM:
  385. x = INT_MAX;
  386. break;
  387. case SB_LINEUP:
  388. x -= 1;
  389. break;
  390. case SB_LINEDOWN:
  391. x += 1;
  392. break;
  393. case SB_PAGEUP:
  394. x -= page;
  395. break;
  396. case SB_PAGEDOWN:
  397. x += page;
  398. break;
  399. case SB_THUMBTRACK:
  400. x = nPos;
  401. break;
  402. }
  404. if(x>max)
  405. x = max;
  406. m_sbHorz.SetScrollPos(x);//pParent->GetScrollPos(SB_HORZ));
  407. break;
  408. }
  409. }
  410. }
  412. CSheetsWnd::OnHScroll(nSBCode, nPos, pScrollBar);
  413. }
  415. // Function name : CSheetReport::bSplitter
  416. // Description     : Return TRUE if splitter is showen in object, Private function.
  417. // Return type : BOOL 
  418. BOOL CSheetReport::bSplitter()
  419. {
  420. return !(GetSplitterRect().IsRectEmpty());
  421. }
  423. // Function name : CSheetReport::EraseExclude
  424. // Description     : When WM_ERASEBKGND occurs, then CSheetsWnd::OnEraseBkGnd,
  425. // require a rect that will be excluded from area erased.
  426. // Return type : CRect 
  427. CRect CSheetReport::EraseExclude()
  428. {
  429. CRect rSplitter = GetSplitterRect();
  430. return m_DrawRect + CRect(0,0, rSplitter.IsRectEmpty() ? 0 : m_nDXSplitter,0);
  431. }
  433. // Function name : CSheetReport::GetSplitterRect
  434. // Description     : If user want no splitter, must override this function, and return empty rect
  435. // Return type : CRect 
  436. CRect CSheetReport::GetSplitterRect()
  437. {
  438. CRect result(0,0,0,0);
  439. if (m_sbHorz.IsWindowVisible())
  440. result = CRect(m_DrawRect.right, m_DrawRect.top, m_DrawRect.right + m_nDXSplitter, m_DrawRect.bottom);
  441. return result;
  442. }
  444. // Function name : CSheetReport::GetScrollBar
  445. // Description     : Return the scroll bar of this object, created in OnCreate function
  446. // Return type : CScrollBar& 
  447. CScrollBar& CSheetReport::GetScrollBar()
  448. {
  449. return m_sbHorz;
  450. }
  452. // Function name : CSheetReport::GetPageIndex
  453. // Description     : Search for a pags with title lpszTitle, and return its position
  454. // Return type : int 
  455. // Argument         : LPCTSTR lpszTitle
  456. int CSheetReport::GetPageIndex(CWnd * pWnd)
  457. {
  458. int n = -1;
  459. for (int i = 0; i < m_arrViews.GetSize(); i++)
  460. {
  461. if (pWnd == m_arrViews[i])
  462. {
  463. n = i;
  464. break;
  465. }
  466. }
  467. return n;
  468. }
  470. // Function name : CSheetReport::AddPage
  471. // Description     : Add a new page to object, and return index position
  472. // Return type : int 
  473. // Argument         : LPCTSTR lpszTitle
  474. int CSheetReport::AddPage(LPCTSTR lpszTitle)
  475. {
  476. COutputReport * pWnd = new COutputReport();
  477. pWnd->m_strName = lpszTitle;
  478. if(!pWnd->Create(NULL,"123",WS_CHILD|WS_VISIBLE,CRect(0,0,100,100),GetParent(),100))
  479. {
  480. delete pWnd;
  481. return -1;
  482. }
  484. static COLORREF rgbText[16] = 
  485. {
  486. RGB(0,128,0),
  487. RGB(0,0,255),
  488. RGB(255,255,0),
  489. RGB(255,0,0),
  490. RGB(0,0,128),
  491. RGB(255,0,255),
  492. RGB(0,255,255),
  493. RGB(0,0,0),
  494. RGB(0,0,0),
  495. RGB(0,0,0),
  496. RGB(0,0,0),
  497. RGB(0,0,0),
  498. RGB(0,0,0),
  499. RGB(0,0,0),
  500. RGB(0,0,0),
  501. RGB(255,255,255)
  502. };
  503. pWnd->SetColourTable(rgbText);
  504. //CShowCase
  505. /* if(!pWnd->Create(WS_CHILD|WS_VISIBLE|ES_MULTILINE|ES_AUTOVSCROLL|WS_VSCROLL|ES_AUTOHSCROLL,CRect(0,0,0,0),GetParent(),1111))
  506. {
  507. delete pWnd;
  508. return -1;
  509. }
  510. */
  511. // pWnd->SetBackgroundColor(FALSE,RGB(0,0,0));
  512. //C
  513. /* if(!pWnd->Create(NULL,"",WS_CHILD|WS_VISIBLE|WS_VSCROLL,CRect(0,0,0,0),GetParent(),1111))
  514. {
  515. delete pWnd;
  516. return -1;
  517. }
  518. */
  519. // LOGFONT  LogFont;
  520. // m_fontSys.GetLogFont( &LogFont );
  521. //// pWnd->SetFont(&m_fontSys);
  522. //// pWnd->SetReadOnly();
  523. // pWnd->SetWindowText(lpszTitle);
  524. pWnd->ShowWindow(SW_HIDE);
  525. //// pWnd->Initialize();
  527. /* pWnd->SetCaseSensitive(FALSE);
  528. pWnd->SetStringQuotes(_T("""));
  529. pWnd->SetSLComment(_T('''));
  530. pWnd->SetSLComment(_T("rem"));
  531. */
  532. // pWnd->AddKeywords(szKeywords);
  533. // pWnd->AddConstants(szConstants);
  536. int nResult = m_arrViews.Add(pWnd);
  537. pWnd->m_nChildID = nResult;
  538. Invalidate();
  539. return nResult;
  540. }
  542. // Function name : CSheetReport::RemovePage
  543. // Description     : Remove page with title lpszTitle if founded
  544. // Return type : void 
  545. // Argument         : LPCTSTR lpszTitle
  546. void CSheetReport::RemovePage(LPCTSTR lpszTitle)
  547. {
  548. int nPage = GetPageIndex(lpszTitle);
  549. if (nPage >= 0)
  550. {
  551. COutputReport * pWnd = m_arrViews.GetAt(nPage);
  552. m_arrViews.RemoveAt(nPage);
  553. delete pWnd;
  554. Invalidate();
  555. }
  556. }
  558. // Function name : CSheetReport::RemovePage
  559. // Description     : Remove page by position
  560. // Return type : void 
  561. // Argument         : int nPage
  562. void CSheetReport::RemovePage(int nPage)
  563. {
  564. COutputReport * pWnd = m_arrViews.GetAt(nPage);
  565. m_arrViews.RemoveAt(nPage);
  566. delete pWnd;
  567. Invalidate();
  568. }
  570. // Function name : CSheetReport::BeginDrag
  571. // Description     : Start the dragging page if is case
  572. // Return type : void 
  573. // Argument         : CPoint ptn
  574. void CSheetReport::BeginDrag(CPoint ptn)
  575. {
  576. if (GetDrawRect().PtInRect(ptn))
  577. if (CWnd* pView = GetViewFromPoint(ptn))
  578. {
  579. m_sPageDrag.SetTrackDrag(pView);
  580. SetTimer(IDTIMERWAITTODRAG, WAITTODRAG, NULL);
  581. SetTimer(IDTIMERSCROLL,WAITSCROLL,NULL);
  582. }
  583. }
  585. // Function name : CSheetReport::TrackDrag
  586. // Description     : Continue the dragging page
  587. // Return type : void 
  588. // Argument         : CPoint ptn
  589. void CSheetReport::TrackDrag(CPoint ptn)
  590. {
  591. if (m_sPageDrag.IsDragging())
  592. {
  593. m_sPageDrag.SetTrackDrag(GetViewFromPoint(ptn));
  594. m_sPageDrag.Draw(this);
  595. }
  596. }
  598. // Function name : CSheetReport::EndDrag
  599. // Description     : Stop the draging page
  600. // Return type : void 
  601. // Argument         : CPoint ptn
  602. void CSheetReport::EndDrag(CPoint ptn)
  603. {
  604. KillTimer(IDTIMERWAITTODRAG);
  605. if (m_sPageDrag.IsDragging())
  606. {
  607. KillTimer(IDTIMERSCROLL);
  608. m_sPageDrag.SetTrackDrag(GetViewFromPoint(ptn));
  609. CDragPage sPageDrag(m_sPageDrag);
  610. // Reset the current values drag
  611. m_sPageDrag.Reset();
  612. ReleaseCapture();
  613. // Draw
  614. m_sPageDrag.Draw(this);
  615. // If case, change pages between them
  616. if (sPageDrag.GetTrackDrag() && sPageDrag.GetStartDrag())
  617. if (sPageDrag.GetTrackDrag() != sPageDrag.GetStartDrag())
  618. {
  619. int nS = GetPageIndex(sPageDrag.GetStartDrag());
  620. int nE = GetPageIndex(sPageDrag.GetTrackDrag());
  621. COutputReport * s = m_arrViews.GetAt(nS);
  622. COutputReport * e = m_arrViews.GetAt(nE);
  623. m_arrViews.SetAt(nS,e);
  624. m_arrViews.SetAt(nE,s);
  625. m_nActive = nE;
  626. Invalidate();
  627. }
  628. }
  629. }
  631. // Function name : CSheetReport::OnTimer
  632. // Description     : Wait starting to drag
  633. // Return type : void 
  634. // Argument         : UINT nIDEvent
  635. void CSheetReport::OnTimer(UINT nIDEvent) 
  636. {
  637. CPoint p;
  638. if (GetCursorPos(&p))
  639. {
  640. ScreenToClient(&p);
  641. switch (nIDEvent)
  642. {
  643. case IDTIMERWAITTODRAG:
  644. {
  645. if (CWnd* pViewTrackDrag = m_sPageDrag.GetTrackDrag())
  646. if (GetViewFromPoint(p) == pViewTrackDrag)
  647. {
  648. m_sPageDrag.Set(TRUE, pViewTrackDrag);
  649. m_sPageDrag.Draw(this);
  650. SetCapture();
  651. }
  652. KillTimer(IDTIMERWAITTODRAG);
  653. break;
  654. }
  655. case IDTIMERSCROLL:
  656. {
  657. if (m_sPageDrag.IsDragging())
  658. if (!m_DrawRect.PtInRect(p))
  659. if (p.y > m_DrawRect.top)
  660. if (p.y < m_DrawRect.bottom)
  661. {
  662. m_sPageDrag.SetTrackDrag(GetViewFromPoint(p));
  663. m_sPageDrag.Draw(this);
  664. SendMessage(WM_HSCROLL, MAKEWPARAM(p.x < m_DrawRect.left ? SB_LINELEFT : SB_LINERIGHT, 0), (LPARAM)m_btns.m_hWnd);
  665. }
  666. break;
  667. }
  669. }
  670. }
  672. if(nIDEvent == IDTIMERSPLASH)
  673. {
  674. int nIndex = 0;
  675. COutputReport* pChild;
  676. while (nIndex<m_arrViews.GetSize())
  677. {
  678. pChild = m_arrViews[nIndex];
  679. if(pChild->m_nHasAlert)
  680. {
  681. pChild->m_nSplashCnt = !pChild->m_nSplashCnt;
  682. InvalidateRect(GetPageRect(pChild));
  683. }
  684. nIndex++;
  685. }
  686. }
  687. CSheetsWnd::OnTimer(nIDEvent);
  688. }
  691. int CSheetReport::GetPageIndex(LPCTSTR lpszTitle)
  692. {
  693. int n = -1;
  694. CString str;
  695. for (int i = 0; i < m_arrViews.GetSize(); i++)
  696. {
  698. str = m_arrViews[i]->m_strName;
  699. if (str.CompareNoCase(lpszTitle) == 0)
  700. {
  701. n = i;
  702. break;
  703. }
  704. }
  705. return n;
  707. }
  709. int CSheetReport::AddPage(CWnd *pWnd)
  710. {
  711. int nResult = m_arrViews.Add((COutputReport*)pWnd);
  712. Invalidate();
  713. return nResult;
  715. }
  718. COutputReport * CSheetReport::GetPageAt(int nIndex)
  719. {
  720. if (nIndex < m_arrViews.GetSize() && nIndex>=0)
  721. return m_arrViews[nIndex];
  722. return NULL;
  723. }
  725. void CSheetReport::Splash(int nPage)
  726. {
  727. COutputReport * pView = GetPageAt(nPage);
  728. Splash(pView);
  729. }
  731. CBrush * CSheetReport::GetPageBkBrush(int nPage)
  732. {
  733. COutputReport * pView = GetPageAt(nPage);
  734. return GetPageBkBrush(pView);
  735. }
  737. CBrush * CSheetReport::GetPageBkBrush(CWnd *pView)
  738. {
  739. static CBrush br(RGB(0,255,0));
  740. static CBrush br1(RGB(255,0,0));
  741. static CBrush br2(RGB(255,255,0));
  742. static CBrush br3(RGB(0,0,255));
  743. if(pView)
  744. if(((COutputReport *)pView)->m_nHasAlert && ((COutputReport *)pView)->m_nSplashCnt)
  745. {
  746. switch(((COutputReport *)pView)->m_nChildID)
  747. {
  748. case 0:
  749. return &br;
  750. break;
  751. case 1:
  752. return &br1;
  753. break;
  754. case 2:
  755. return &br2;
  756. break;
  757. default:
  758. return &br3;
  759. break;
  760. }
  761. }
  762. return CSheetsWnd::GetPageBkBrush(pView);
  764. }
  766. void CSheetReport::Splash(CWnd *pView)
  767. {
  768. ((COutputReport*)pView)->m_nSplashCnt = 1;
  769. InvalidateRect(GetPageRect(pView));
  770. }