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

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

SNMP编程

开发平台：

C/C++

CREDITSTATIC.CPP：源码内容
  1. // CreditStatic.cpp : implementation file
  2. //
  4. #include "stdafx.h"
  5. //#include "myapp.h"
  6. #include "CreditStatic.h"
  8. #ifdef _DEBUG
  9. #define new DEBUG_NEW
  10. #undef THIS_FILE
  11. static char THIS_FILE[] = __FILE__;
  12. #endif
  14. #define  DISPLAY_TIMER_ID 150 // timer id
  16. extern CBrush m_brBk;
  17. extern HBITMAP hBkBitmap;
  19. /////////////////////////////////////////////////////////////////////////////
  20. // CCreditStatic
  22. CCreditStatic::CCreditStatic()
  23. {
  25. m_Colors[0] = RGB(0,0,0);       // Black
  26. m_Colors[1] = RGB(255,0,0);     // Red
  27. m_Colors[2] = RGB(255,255,0);   // Yellow
  28. m_Colors[3] = RGB(0,255,255);   // Turquoise
  29. m_Colors[4] = RGB(255,255,255); // White
  31. m_TextHeights[0] = 21;
  32. m_TextHeights[1] = 19;
  33. m_TextHeights[2] = 17;
  34. m_TextHeights[3] = 15;
  35. m_nCurrentFontHeight = m_TextHeights[NORMAL_TEXT_HEIGHT];
  38. m_Escapes[0] = 't';
  39. m_Escapes[1] = 'n';
  40. m_Escapes[2] = 'r';
  41. m_Escapes[3] = '^';
  43. m_DisplaySpeed[0] = 70;
  44. m_DisplaySpeed[1] = 40;
  45. m_DisplaySpeed[2] = 10;
  47. m_CurrentSpeed = 1;
  48. m_ScrollAmount = -1;
  49. m_bProcessingBitmap = FALSE;
  51. m_ArrIndex = NULL;
  52. m_nCounter = 1;
  53. m_nClip = 0;
  55. m_bFirstTime = TRUE;
  56. m_bDrawText = FALSE;
  57. m_bFirstTurn = TRUE;
  58. n_MaxWidth = 0;
  59. TimerOn = 0;
  60. if(hBkBitmap == NULL)
  61. hBkBitmap = (HBITMAP)LoadImage(AfxGetInstanceHandle(),"background.bmp",
  62. IMAGE_BITMAP,0,0,LR_LOADFROMFILE|LR_CREATEDIBSECTION);
  63. if(m_brBk.m_hObject == NULL && hBkBitmap != NULL)
  64. {
  65. CBitmap * bp = CBitmap::FromHandle(hBkBitmap);
  66. m_brBk.CreatePatternBrush(bp);;
  67. }
  68. }
  70. CCreditStatic::~CCreditStatic()
  71. {
  72. }
  75. BEGIN_MESSAGE_MAP(CCreditStatic, CStatic)
  76. //{{AFX_MSG_MAP(CCreditStatic)
  77. ON_WM_PAINT()
  78. ON_WM_ERASEBKGND()
  79. ON_WM_TIMER()
  80. ON_WM_DESTROY()
  81. ON_WM_SIZE()
  82. //}}AFX_MSG_MAP
  83. END_MESSAGE_MAP()
  85. /////////////////////////////////////////////////////////////////////////////
  86. // CCreditStatic message handlers
  88. BOOL CCreditStatic::StartScrolling()
  89. {
  90. if(m_ArrCredit.IsEmpty())
  91. return FALSE;
  93. if(m_BmpMain.m_hObject != NULL) {
  94. m_BmpMain.DeleteObject();
  95. m_BmpMain.m_hObject = NULL;
  96. }
  98. TimerOn = SetTimer(DISPLAY_TIMER_ID,m_DisplaySpeed[m_CurrentSpeed],NULL);
  99. //    ASSERT(TimerOn != 0);
  101. m_ArrIndex = m_ArrCredit.GetHeadPosition();
  102. m_nCounter = 1;
  103. m_nClip = 0;
  105. m_bFirstTime = TRUE;
  106. m_bDrawText = FALSE;
  108. return TRUE;
  109. }
  111. void CCreditStatic::EndScrolling()
  112. {
  113. KillTimer(DISPLAY_TIMER_ID);
  114. TimerOn = 0;
  116. if(m_BmpMain.m_hObject != NULL) {
  117. m_BmpMain.DeleteObject();
  118. m_BmpMain.m_hObject = NULL;
  119. }
  120. }
  122. void CCreditStatic::SetCredits(LPCTSTR credits,char delimiter)
  123. {
  124. char *str,*ptr1,*ptr2;
  125.     
  126. // ASSERT(credits);
  128. if((str = strdup(credits)) == NULL)
  129. return;
  131. m_ArrCredit.RemoveAll();
  133. ptr1 = str;
  134. while((ptr2 = strchr(ptr1,delimiter)) != NULL) {
  135. *ptr2 = '';
  136. m_ArrCredit.AddTail(ptr1);
  137. ptr1 = ptr2+1;
  138. }
  139. m_ArrCredit.AddTail(ptr1);
  141. free(str);
  143. m_ArrIndex = m_ArrCredit.GetHeadPosition();
  144. m_nCounter = 1;
  145. m_nClip = 0;
  147. m_bFirstTime = TRUE;
  148. m_bDrawText = FALSE;
  149. }
  151. void CCreditStatic::SetCredits(UINT nID,char delimiter)
  152. {
  153. CString credits;
  154. if(!credits.LoadString(nID))
  155. return;
  157. SetCredits((LPCTSTR)credits, delimiter);
  158. }
  160. void CCreditStatic::SetSpeed(UINT index, int speed)
  161. {
  162. // ASSERT(index <= DISPLAY_FAST);
  164. if(speed)
  165. m_DisplaySpeed[index] = speed;
  167. m_CurrentSpeed = index;
  168. }
  170. void CCreditStatic::SetColor(UINT index, COLORREF col)
  171. {
  172. // ASSERT(index <= NORMAL_TEXT_COLOR);
  174. m_Colors[index] = col;
  175. }
  177. void CCreditStatic::SetTextHeight(UINT index, int height)
  178. {
  179. // ASSERT(index <= NORMAL_TEXT_HEIGHT);
  181. m_TextHeights[index] = height;
  182. }
  184. void CCreditStatic::SetEscape(UINT index, char escape)
  185. {
  186. // ASSERT(index <= DISPLAY_BITMAP);
  188. m_Escapes[index] = escape;
  189. }
  191. void CCreditStatic::OnPaint() 
  192. {
  193. CPaintDC dc(this); // device context for painting
  195. if(TimerOn) return;
  197. CRect m_ScrollRect,rcClip;
  198. GetClientRect(&m_ScrollRect);
  199. dc.GetClipBox(&rcClip);
  200. DrawCredit(&dc, m_ScrollRect);
  201. AddBackGround(&dc, m_ScrollRect, rcClip);
  202. }
  204. BOOL CCreditStatic::OnEraseBkgnd(CDC* pDC) 
  205. {
  206. if(m_brBk.m_hObject)
  207. {
  208. CRect rc;
  209. GetClientRect(rc);
  210. pDC->FillRect(rc,&m_brBk);
  211. }
  212. return TRUE;
  214. // return CStatic::OnEraseBkgnd(pDC);
  215. }
  217. //************************************************************************
  218. //  OnTimer
  219. //
  220. //   On each of the display timers, scroll the window 1 unit. Each 20
  221. //      units, fetch the next array element and load into work string. Call
  222. //      Invalidate and UpdateWindow to invoke the OnPaint which will paint 
  223. //      the contents of the newly updated work string.
  224. //************************************************************************
  225. void CCreditStatic::OnTimer(UINT nIDEvent) 
  226. {
  227. if (nIDEvent != DISPLAY_TIMER_ID)
  228. {
  229. CStatic::OnTimer(nIDEvent);
  230. return;
  231. }
  233. BOOL bCheck = FALSE;
  235. if (!m_bProcessingBitmap) {
  236. if (m_nCounter++ % m_nCurrentFontHeight == 0)  // every x timer events, show new line
  237. {
  238. m_nCounter=1;
  239. m_szWork = m_ArrCredit.GetNext(m_ArrIndex);
  240. if(m_bFirstTurn)
  241. bCheck = TRUE;
  242. if(m_ArrIndex == NULL) {
  243. m_bFirstTurn = FALSE;
  244. m_ArrIndex = m_ArrCredit.GetHeadPosition();
  245. }
  246. m_nClip = 0;
  247. m_bDrawText=TRUE;
  248. }
  249. }
  251.     CClientDC dc(this);
  252. CRect m_ScrollRect;
  253. GetClientRect(&m_ScrollRect);
  254.  
  255. CRect m_ClientRect(m_ScrollRect);
  256. m_ClientRect.left = (m_ClientRect.Width()-n_MaxWidth)/2;
  257. m_ClientRect.right = m_ClientRect.left + n_MaxWidth;
  259. MoveCredit(&dc, m_ScrollRect, m_ClientRect, bCheck);
  261. AddBackGround(&dc, m_ScrollRect, m_ClientRect);
  263. CStatic::OnTimer(nIDEvent);
  264. }
  266. void CCreditStatic::AddBackGround(CDC* pDC, CRect& m_ScrollRect, CRect& m_ClientRect)
  267. {
  268. CDC memDC;
  269. memDC.CreateCompatibleDC( pDC );
  271.     if( m_bitmap.m_hObject == NULL )
  272. {
  273.         CBitmap* pOldBitmap = memDC.SelectObject( &m_BmpMain );
  274.         pDC->BitBlt( 0, 0, m_ScrollRect.Width(), m_ScrollRect.Height(), 
  275.                                         &memDC, 0, 0, SRCCOPY );
  276. memDC.SelectObject(pOldBitmap);
  277. return;
  278. }
  280.    // Draw bitmap in the background if one has been set
  281.                 // Now create a mask
  282. CBitmap bitmap;
  283. bitmap.CreateCompatibleBitmap( pDC, m_ClientRect.Width(), m_ClientRect.Height() );
  284. CBitmap* pOldMemDCBitmap = memDC.SelectObject( &bitmap );
  286. CDC tempDC;
  287. tempDC.CreateCompatibleDC(pDC);
  288. CBitmap* pOldTempDCBitmap = tempDC.SelectObject( &m_BmpMain );
  290. memDC.BitBlt( 0, 0, m_ClientRect.Width(), m_ClientRect.Height(), &tempDC, 
  291.                       m_ClientRect.left, m_ClientRect.top, SRCCOPY );
  292. CDC maskDC;
  293. maskDC.CreateCompatibleDC(pDC);
  294. CBitmap maskBitmap;
  296. // Create monochrome bitmap for the mask
  297. maskBitmap.CreateBitmap( m_ClientRect.Width(), m_ClientRect.Height(), 1, 1, NULL );
  298. CBitmap* pOldMaskDCBitmap = maskDC.SelectObject( &maskBitmap );
  299.     memDC.SetBkColor(m_Colors[BACKGROUND_COLOR]);
  301. // Create the mask from the memory DC
  302. maskDC.BitBlt( 0, 0, m_ClientRect.Width(), m_ClientRect.Height(), &memDC, 0, 0, SRCCOPY );
  304. tempDC.SelectObject(pOldTempDCBitmap);
  305. pOldTempDCBitmap = tempDC.SelectObject( &m_bitmap );
  307. CDC imageDC;
  308. CBitmap bmpImage;
  309. imageDC.CreateCompatibleDC( pDC );
  310. bmpImage.CreateCompatibleBitmap( pDC, m_ScrollRect.Width(), m_ScrollRect.Height() );
  311. CBitmap* pOldImageDCBitmap = imageDC.SelectObject( &bmpImage );
  313. if( pDC->GetDeviceCaps(RASTERCAPS) & RC_PALETTE && m_pal.m_hObject != NULL )
  314. {
  315. pDC->SelectPalette( &m_pal, FALSE );
  316. pDC->RealizePalette();
  318. imageDC.SelectPalette( &m_pal, FALSE );
  319. }
  320. // Get x and y offset
  321. // Draw bitmap in tiled manner to imageDC
  322. for( int i = 0; i < m_ScrollRect.right; i += m_cxBitmap )
  323. for( int j = 0; j < m_ScrollRect.bottom; j += m_cyBitmap )
  324. imageDC.BitBlt( i, j, m_cxBitmap, m_cyBitmap, &tempDC, 0, 0, SRCCOPY );
  326. // Set the background in memDC to black. Using SRCPAINT with black and any other
  327. // color results in the other color, thus making black the transparent color
  328. memDC.SetBkColor(RGB(0,0,0));
  329. memDC.SetTextColor(RGB(255,255,255));
  330. memDC.BitBlt(0, 0, m_ClientRect.Width(), m_ClientRect.Height(), &maskDC, 0, 0, SRCAND);
  332. // Set the foreground to black. See comment above.
  333. imageDC.SetBkColor(RGB(255,255,255));
  334. imageDC.SetTextColor(RGB(0,0,0));
  335. imageDC.BitBlt(m_ClientRect.left, m_ClientRect.top, m_ClientRect.Width(), m_ClientRect.Height(), 
  336. &maskDC, 0, 0, SRCAND);
  338. // Combine the foreground with the background
  339.     imageDC.BitBlt(m_ClientRect.left, m_ClientRect.top, m_ClientRect.Width(), m_ClientRect.Height(), 
  340. &memDC, 0, 0,SRCPAINT);
  342. // Draw the final image to the screen   
  343. pDC->BitBlt( 0, 0, m_ScrollRect.Width(), m_ScrollRect.Height(), 
  344. &imageDC, 0, 0, SRCCOPY );
  346. imageDC.SelectObject(pOldImageDCBitmap);
  347. maskDC.SelectObject(pOldMaskDCBitmap);
  348. tempDC.SelectObject(pOldTempDCBitmap);
  349. memDC.SelectObject(pOldMemDCBitmap);
  350. }
  352. void CCreditStatic::MoveCredit(CDC* pDC, CRect& m_ScrollRect, CRect& m_ClientRect, BOOL bCheck)
  353. {
  354. CDC memDC,memDC2;
  355.     memDC.CreateCompatibleDC(pDC);
  356.     memDC2.CreateCompatibleDC(pDC);
  357.     
  358. // CBrush bBrush(m_Colors[BACKGROUND_COLOR]);
  359. CBrush* pOldBrush = memDC.SelectObject(&m_brBk);
  360. CBitmap *pOldMemDCBitmap = NULL;
  361. CBitmap *pOldMemDC2Bitmap = NULL;
  363. if(m_BmpMain.m_hObject == NULL) {
  364. m_BmpMain.CreateCompatibleBitmap( pDC, m_ScrollRect.Width(), m_ScrollRect.Height() );
  365. pOldMemDCBitmap = (CBitmap*)memDC.SelectObject(&m_BmpMain);
  366. memDC.FillRect(&m_ScrollRect,&m_brBk);
  367. } else 
  368. pOldMemDCBitmap = (CBitmap*)memDC.SelectObject(&m_BmpMain);
  370. if(m_ClientRect.Width() > 0) {
  371. CBitmap bitmap;
  372. bitmap.CreateCompatibleBitmap( pDC, m_ClientRect.Width(), m_ClientRect.Height() );
  373. pOldMemDC2Bitmap = memDC2.SelectObject(&bitmap);
  375. memDC2.BitBlt( 0, 0, m_ClientRect.Width(), m_ClientRect.Height()-abs(m_ScrollAmount), 
  376.              &memDC, m_ClientRect.left, abs(m_ScrollAmount), SRCCOPY );
  377. memDC.BitBlt( m_ClientRect.left, 0, m_ClientRect.Width(), m_ClientRect.Height(), 
  378.              &memDC2, 0, 0, SRCCOPY );
  381. memDC2.SelectObject(pOldMemDC2Bitmap);
  382. pOldMemDC2Bitmap = NULL;
  383.     }
  384. m_nClip = m_nClip + abs(m_ScrollAmount);
  387. //*********************************************************************
  388. // FONT SELECTION
  389.     CFont m_fntArial;
  390. CFont* pOldFont = NULL;
  391. BOOL bSuccess = FALSE;
  393. BOOL bUnderline;
  394. BOOL bItalic;
  395.     int rmcode = 0;
  397. if (!m_szWork.IsEmpty()) {
  398. char c = m_szWork[m_szWork.GetLength()-1];
  399. if(c == m_Escapes[TOP_LEVEL_GROUP]) {
  400. rmcode = 1;
  401. bItalic = FALSE;
  402. bUnderline = FALSE;
  403. m_nCurrentFontHeight = m_TextHeights[TOP_LEVEL_GROUP_HEIGHT];
  404.     bSuccess = m_fntArial.CreateFont(m_TextHeights[TOP_LEVEL_GROUP_HEIGHT], 0, 0, 0, 
  405.     FW_BOLD, bItalic, bUnderline, 0, 
  406.     ANSI_CHARSET,
  407.                     OUT_DEFAULT_PRECIS,
  408.                     CLIP_DEFAULT_PRECIS,
  409.                     PROOF_QUALITY,
  410.                     VARIABLE_PITCH | 0x04 | FF_DONTCARE,
  411.                     (LPSTR)"Arial");
  412. memDC.SetTextColor(m_Colors[TOP_LEVEL_GROUP_COLOR]);
  413. if (pOldFont != NULL) memDC.SelectObject(pOldFont);
  414. pOldFont = memDC.SelectObject(&m_fntArial);
  416. }
  417. else if(c == m_Escapes[GROUP_TITLE]) {
  418. rmcode = 1;
  419. bItalic = FALSE;
  420. bUnderline = FALSE;
  421. m_nCurrentFontHeight = m_TextHeights[GROUP_TITLE_HEIGHT];
  422.     bSuccess = m_fntArial.CreateFont(m_TextHeights[GROUP_TITLE_HEIGHT], 0, 0, 0, 
  423.     FW_BOLD, bItalic, bUnderline, 0, 
  424.     ANSI_CHARSET,
  425.                     OUT_DEFAULT_PRECIS,
  426.                     CLIP_DEFAULT_PRECIS,
  427.                     PROOF_QUALITY,
  428.                     VARIABLE_PITCH | 0x04 | FF_DONTCARE,
  429.                     (LPSTR)"Arial");
  430. memDC.SetTextColor(m_Colors[GROUP_TITLE_COLOR]);
  431. if (pOldFont != NULL) memDC.SelectObject(pOldFont);
  432. pOldFont = memDC.SelectObject(&m_fntArial);
  433. }
  434. else if(c == m_Escapes[TOP_LEVEL_TITLE]) {
  435. rmcode = 1;
  436. bItalic = FALSE;
  437. // bUnderline = TRUE;
  438. bUnderline = FALSE;
  439. m_nCurrentFontHeight = m_TextHeights[TOP_LEVEL_TITLE_HEIGHT];
  440. bSuccess = m_fntArial.CreateFont(m_TextHeights[TOP_LEVEL_TITLE_HEIGHT], 0, 0, 0, 
  441. FW_BOLD, bItalic, bUnderline, 0, 
  442. ANSI_CHARSET,
  443.                 OUT_DEFAULT_PRECIS,
  444.                 CLIP_DEFAULT_PRECIS,
  445.                 PROOF_QUALITY,
  446.                 VARIABLE_PITCH | 0x04 | FF_DONTCARE,
  447.                 (LPSTR)"Arial");
  448. memDC.SetTextColor(m_Colors[TOP_LEVEL_TITLE_COLOR]);
  449. if (pOldFont != NULL) memDC.SelectObject(pOldFont);
  450. pOldFont = memDC.SelectObject(&m_fntArial);
  451. }
  452. else if(c == m_Escapes[DISPLAY_BITMAP]) {
  453. if (!m_bProcessingBitmap)
  454. {
  455. CString szBitmap = m_szWork.Left(m_szWork.GetLength()-1);
  456. if(m_bmpWork.LoadBitmap((const char *)szBitmap)) {
  457. BITMAP  m_bmpInfo;
  459.     m_bmpWork.GetObject(sizeof(BITMAP), &m_bmpInfo);
  461. m_size.cx = m_bmpInfo.bmWidth; // width  of dest rect
  462. m_size.cy = m_bmpInfo.bmHeight;
  463. // upper left point of dest
  464. m_pt.x = (m_ClientRect.right - 
  465. ((m_ClientRect.Width())/2) - (m_size.cx/2));
  466. m_pt.y = m_ClientRect.bottom;
  468. m_bProcessingBitmap = TRUE;
  469. if (pOldMemDC2Bitmap != NULL) memDC2.SelectObject(pOldMemDC2Bitmap);
  470. pOldMemDC2Bitmap = memDC2.SelectObject(&m_bmpWork);
  471. }
  472. else
  473. c = ' ';
  474. }
  475. else {
  476. if (pOldMemDC2Bitmap != NULL) memDC2.SelectObject(pOldMemDC2Bitmap);
  477. pOldMemDC2Bitmap = memDC2.SelectObject(&m_bmpWork);
  478. }
  479. }
  480. else {
  481. bItalic = FALSE;
  482. bUnderline = FALSE;
  483. m_nCurrentFontHeight = m_TextHeights[NORMAL_TEXT_HEIGHT];
  484.     bSuccess = m_fntArial.CreateFont(m_TextHeights[NORMAL_TEXT_HEIGHT], 0, 0, 0, 
  485.     FW_THIN, bItalic, bUnderline, 0, 
  486.     ANSI_CHARSET,
  487.                     OUT_DEFAULT_PRECIS,
  488.                     CLIP_DEFAULT_PRECIS,
  489.                     PROOF_QUALITY,
  490.                     VARIABLE_PITCH | 0x04 | FF_DONTCARE,
  491.                     (LPSTR)"Arial");
  492. memDC.SetTextColor(m_Colors[NORMAL_TEXT_COLOR]);
  493. if (pOldFont != NULL) memDC.SelectObject(pOldFont);
  494. pOldFont = memDC.SelectObject(&m_fntArial);
  495. }
  496. }
  498. CRect r1(m_ScrollRect);
  499. r1.top = r1.bottom-abs(m_ScrollAmount);
  501. memDC.FillRect(&r1,&m_brBk);
  502. memDC.SetBkMode(TRANSPARENT);
  504. if (!m_bProcessingBitmap)
  505. {
  506. if(bCheck) {
  507. CSize size = memDC.GetTextExtent((LPCTSTR)m_szWork,m_szWork.GetLength()-rmcode);
  508. if(size.cx > n_MaxWidth) {
  509. n_MaxWidth = (size.cx > m_ScrollRect.Width())? m_ScrollRect.Width():size.cx;
  510. m_ClientRect.left = (m_ScrollRect.Width()-n_MaxWidth)/2;
  511. m_ClientRect.right = m_ClientRect.left + n_MaxWidth;
  512. }
  514. }
  515. CRect r(m_ClientRect);
  516. r.top = r.bottom-m_nClip;
  517. int x = memDC.DrawText((const char *)m_szWork,m_szWork.GetLength()-rmcode,&r,DT_TOP|DT_CENTER|
  518. DT_NOPREFIX | DT_SINGLELINE);
  519. m_bDrawText=FALSE;
  520. }
  521. else
  522. {
  523. if(bCheck) {
  524. CSize size = memDC.GetTextExtent((LPCTSTR)m_szWork,m_szWork.GetLength()-rmcode);
  525. if(m_size.cx > n_MaxWidth) {
  526. n_MaxWidth = (m_size.cx > m_ScrollRect.Width())? m_ScrollRect.Width():m_size.cx;
  527. m_ClientRect.left = (m_ScrollRect.Width()-n_MaxWidth)/2;
  528. m_ClientRect.right = m_ClientRect.left + n_MaxWidth;
  529. }
  530. }
  531.      memDC.BitBlt( m_pt.x, m_pt.y-m_nClip, m_size.cx, m_nClip, 
  532.             &memDC2, 0, 0, SRCCOPY );
  533. if (m_nClip > m_size.cy)
  534. {
  535. m_bmpWork.DeleteObject();
  536. m_bProcessingBitmap = FALSE;
  537. m_nClip=0;
  538. m_szWork.Empty();
  539. m_nCounter=1;
  540. }
  541. }
  543. if (pOldMemDC2Bitmap != NULL) memDC2.SelectObject(pOldMemDC2Bitmap);
  544. if (pOldFont != NULL) memDC.SelectObject(pOldFont);
  545. memDC.SelectObject(pOldBrush);
  546. memDC.SelectObject(pOldMemDCBitmap);
  547. }
  549. void CCreditStatic::DrawCredit(CDC* pDC, CRect& m_ScrollRect)
  550. {
  551. if(m_BmpMain.m_hObject != NULL) return;
  553. CDC memDC,memDC2;
  554.     memDC.CreateCompatibleDC(pDC);
  555.     memDC2.CreateCompatibleDC(pDC);
  556.     
  557. // CBrush bBrush(m_Colors[BACKGROUND_COLOR]);
  558. CBrush* pOldBrush = memDC.SelectObject(&m_brBk);
  559. CBitmap *pOldMemDCBitmap = NULL;
  560. CBitmap *pOldMemDC2Bitmap = NULL;
  562. m_BmpMain.CreateCompatibleBitmap( pDC, m_ScrollRect.Width(), m_ScrollRect.Height() );
  563. pOldMemDCBitmap = (CBitmap*)memDC.SelectObject(&m_BmpMain);
  565. memDC.FillRect(&m_ScrollRect,&m_brBk);
  567. POSITION pos = m_ArrCredit.GetHeadPosition();
  568. int height = 0;
  569. CFont m_fntArial;
  570. CFont *pOldFont = NULL;
  571. while(pos != NULL && height <= m_ScrollRect.Height()) {
  572. CString m_szWork = m_ArrCredit.GetNext(pos);
  574. CDC memDC2;
  575. memDC2.CreateCompatibleDC(pDC);
  576. //*********************************************************************
  577. // FONT SELECTION
  580. BOOL bSuccess = FALSE;
  581. BOOL bIsBitmap = FALSE;
  583. BOOL bUnderline;
  584. BOOL bItalic;
  585. int rmcode = 0;
  586.         CBitmap bitmap;
  588. if (!m_szWork.IsEmpty()) {
  589. char c = m_szWork[m_szWork.GetLength()-1];
  590. if(c == m_Escapes[TOP_LEVEL_GROUP]) {
  591. rmcode = 1;
  592. bItalic = FALSE;
  593. bUnderline = FALSE;
  594. m_nCurrentFontHeight = m_TextHeights[TOP_LEVEL_GROUP_HEIGHT];
  595.     bSuccess = m_fntArial.CreateFont(m_TextHeights[TOP_LEVEL_GROUP_HEIGHT], 0, 0, 0, 
  596.     FW_BOLD, bItalic, bUnderline, 0, 
  597.     ANSI_CHARSET,
  598.                     OUT_DEFAULT_PRECIS,
  599.                     CLIP_DEFAULT_PRECIS,
  600.                     PROOF_QUALITY,
  601.                     VARIABLE_PITCH | 0x04 | FF_DONTCARE,
  602.                     (LPSTR)"Arial");
  603. memDC.SetTextColor(m_Colors[TOP_LEVEL_GROUP_COLOR]);
  604. pOldFont = memDC.SelectObject(&m_fntArial);
  606. }
  607. else if(c == m_Escapes[GROUP_TITLE]) {
  608. rmcode = 1;
  609. bItalic = FALSE;
  610. bUnderline = FALSE;
  611. m_nCurrentFontHeight = m_TextHeights[GROUP_TITLE_HEIGHT];
  612.     bSuccess = m_fntArial.CreateFont(m_TextHeights[GROUP_TITLE_HEIGHT], 0, 0, 0, 
  613.     FW_BOLD, bItalic, bUnderline, 0, 
  614.     ANSI_CHARSET,
  615.                     OUT_DEFAULT_PRECIS,
  616.                     CLIP_DEFAULT_PRECIS,
  617.                     PROOF_QUALITY,
  618.                     VARIABLE_PITCH | 0x04 | FF_DONTCARE,
  619.                     (LPSTR)"Arial");
  620. memDC.SetTextColor(m_Colors[GROUP_TITLE_COLOR]);
  621. if (pOldFont != NULL) memDC.SelectObject(pOldFont);
  622. pOldFont = memDC.SelectObject(&m_fntArial);
  623. }
  624. else if(c == m_Escapes[TOP_LEVEL_TITLE]) {
  625. rmcode = 1;
  626. bItalic = FALSE;
  627. // bUnderline = TRUE;
  628. bUnderline = FALSE;
  629. m_nCurrentFontHeight = m_TextHeights[TOP_LEVEL_TITLE_HEIGHT];
  630. bSuccess = m_fntArial.CreateFont(m_TextHeights[TOP_LEVEL_TITLE_HEIGHT], 0, 0, 0, 
  631. FW_BOLD, bItalic, bUnderline, 0, 
  632. ANSI_CHARSET,
  633.                 OUT_DEFAULT_PRECIS,
  634.                 CLIP_DEFAULT_PRECIS,
  635.                 PROOF_QUALITY,
  636.                 VARIABLE_PITCH | 0x04 | FF_DONTCARE,
  637.                 (LPSTR)"Arial");
  638. memDC.SetTextColor(m_Colors[TOP_LEVEL_TITLE_COLOR]);
  639. if (pOldFont != NULL) memDC.SelectObject(pOldFont);
  640. pOldFont = memDC.SelectObject(&m_fntArial);
  641. }
  642. else if(c == m_Escapes[DISPLAY_BITMAP]) {
  643. CString szBitmap = m_szWork.Left(m_szWork.GetLength()-1);
  644. if(bitmap.LoadBitmap((const char *)szBitmap)) {
  645. BITMAP  m_bmpInfo;
  647.     bitmap.GetObject(sizeof(BITMAP), &m_bmpInfo);
  649. m_size.cx = m_bmpInfo.bmWidth; // width  of dest rect
  650. m_size.cy = m_bmpInfo.bmHeight;
  651. // upper left point of dest
  652. m_pt.x = (m_ScrollRect.right - 
  653. ((m_ScrollRect.Width())/2) - (m_size.cx/2));
  654. m_pt.y = height;
  655. pOldMemDC2Bitmap = memDC2.SelectObject(&bitmap);
  656. bIsBitmap = TRUE;
  657. }
  658. else
  659. c = ' ';
  660. }
  661. else {
  662. bItalic = FALSE;
  663. bUnderline = FALSE;
  664. m_nCurrentFontHeight = m_TextHeights[NORMAL_TEXT_HEIGHT];
  665.     bSuccess = m_fntArial.CreateFont(m_TextHeights[NORMAL_TEXT_HEIGHT], 0, 0, 0, 
  666.     FW_THIN, bItalic, bUnderline, 0, 
  667.     ANSI_CHARSET,
  668.                     OUT_DEFAULT_PRECIS,
  669.                     CLIP_DEFAULT_PRECIS,
  670.                     PROOF_QUALITY,
  671.                     VARIABLE_PITCH | 0x04 | FF_DONTCARE,
  672.                     (LPSTR)"Arial");
  673. memDC.SetTextColor(m_Colors[NORMAL_TEXT_COLOR]);
  674. if (pOldFont != NULL) memDC.SelectObject(pOldFont);
  675. pOldFont = memDC.SelectObject(&m_fntArial);
  676. }
  677. }
  679. memDC.SetBkMode(TRANSPARENT);
  681. if (!bIsBitmap)
  682. {
  683. CRect r(m_ScrollRect);
  684. r.top = height;
  685. CSize size;
  686. if(m_szWork.GetLength()-rmcode != 0) 
  687. {
  688. int x = memDC.DrawText((const char *)m_szWork,m_szWork.GetLength()-rmcode,&r,DT_TOP|DT_CENTER|
  689. DT_NOPREFIX | DT_SINGLELINE);
  690. size = memDC.GetTextExtent((LPCTSTR)m_szWork,m_szWork.GetLength()-rmcode);
  691. }
  692. else
  693. size = memDC.GetTextExtent((LPCTSTR)"W",1);
  694. height += size.cy;
  695. }
  696. else
  697. {
  698.      memDC.BitBlt( m_pt.x, m_pt.y, m_size.cx, m_size.cy, &memDC2, 0, 0, SRCCOPY );
  699. height += m_size.cy;
  700. }
  701. }
  702. if(height && height < m_ScrollRect.Height()) {
  703. CDC memDC3;
  704. memDC3.CreateCompatibleDC(pDC);
  706. int y = (m_ScrollRect.Height() - height)/2;
  707. CBitmap bitmap;
  708. bitmap.CreateCompatibleBitmap( pDC, m_ScrollRect.Width(), height);
  709. CBitmap* pOldMemDC3Bitmap = memDC3.SelectObject(&bitmap);
  711. memDC3.BitBlt( 0, 0, m_ScrollRect.Width(), height, 
  712.                &memDC, 0, 0, SRCCOPY );
  713. CRect r(0,0,m_ScrollRect.Width(),y);
  714. memDC.FillRect(&r,&m_brBk);
  715. memDC.BitBlt( 0, y, m_ScrollRect.Width(), height, 
  716.                       &memDC2, 0, 0, SRCCOPY );
  718. memDC3.SelectObject(pOldMemDC3Bitmap);
  719. }
  720. if (pOldFont != NULL) memDC.SelectObject(pOldFont);
  721. if (pOldMemDC2Bitmap != NULL) memDC2.SelectObject(pOldMemDC2Bitmap);
  722. memDC.SelectObject(pOldBrush);
  723. memDC.SelectObject(pOldMemDCBitmap);
  724. }
  726. void CCreditStatic::OnDestroy() 
  727. {
  728. CStatic::OnDestroy();
  730. m_ArrCredit.RemoveAll();
  732. if(TimerOn)
  733. ASSERT(KillTimer(DISPLAY_TIMER_ID));
  734. }
  736. BOOL CCreditStatic::SetBkImage(UINT nIDResource)
  737. {
  738.     return SetBkImage( (LPCTSTR)nIDResource );
  739. }
  741. BOOL CCreditStatic::SetBkImage(LPCTSTR lpszResourceName)
  742. {
  744.     // If this is not the first call then Delete GDI objects
  745.     if( m_bitmap.m_hObject != NULL )
  746. m_bitmap.DeleteObject();
  747.     if( m_pal.m_hObject != NULL )
  748. m_pal.DeleteObject();
  749.     
  750.     
  751.     HBITMAP hBmp = (HBITMAP)::LoadImage( AfxGetInstanceHandle(), 
  752.             lpszResourceName, IMAGE_BITMAP, 0,0, LR_CREATEDIBSECTION );
  754.      if( hBmp == NULL ) 
  755.         return FALSE;
  757. m_bitmap.Attach( hBmp );
  758.     BITMAP bm;
  759.     m_bitmap.GetBitmap( &bm );
  760.     m_cxBitmap = bm.bmWidth;
  761.     m_cyBitmap = bm.bmHeight;
  763.     // Create a logical palette for the bitmap
  764.     DIBSECTION ds;
  765.     BITMAPINFOHEADER &bmInfo = ds.dsBmih;
  766.     m_bitmap.GetObject( sizeof(ds), &ds );
  768.     int nColors = bmInfo.biClrUsed ? bmInfo.biClrUsed : 1 << bmInfo.biBitCount;
  770.     // Create a halftone palette if colors > 256. 
  771.     CClientDC dc(NULL);             // Desktop DC
  772.     if( nColors > 256 )
  773.         m_pal.CreateHalftonePalette( &dc );
  774.     else
  775.     {
  776.         // Create the palette
  778.         RGBQUAD *pRGB = new RGBQUAD[nColors];
  779.         CDC memDC;
  780.         memDC.CreateCompatibleDC(&dc);
  782.         CBitmap* pOldMemDCBitmap = memDC.SelectObject( &m_bitmap );
  783.         ::GetDIBColorTable( memDC, 0, nColors, pRGB );
  785.         UINT nSize = sizeof(LOGPALETTE) + (sizeof(PALETTEENTRY) * nColors);
  786.         LOGPALETTE *pLP = (LOGPALETTE *) new BYTE[nSize];
  788.         pLP->palVersion = 0x300;
  789.         pLP->palNumEntries = nColors;
  791.         for( int i=0; i < nColors; i++)
  792.         {
  793.             pLP->palPalEntry[i].peRed = pRGB[i].rgbRed;
  794.             pLP->palPalEntry[i].peGreen = pRGB[i].rgbGreen;
  795.             pLP->palPalEntry[i].peBlue = pRGB[i].rgbBlue;
  796.             pLP->palPalEntry[i].peFlags = 0;
  797.         }
  799.         m_pal.CreatePalette( pLP );
  801. memDC.SelectObject(pOldMemDCBitmap);
  802.         delete[] pLP;
  803.         delete[] pRGB;
  804.     }
  805. //    Invalidate();
  807.     return TRUE;
  808. }
  810. void CCreditStatic::OnSize(UINT nType, int cx, int cy) 
  811. {
  812. CStatic::OnSize(nType, cx, cy);
  814. // TODO: Add your message handler code here
  815. if (nType != SIZE_MINIMIZED && cx != 0 && cy != 0 )
  816. {
  817. EndScrolling();
  818. StartScrolling();
  819. }
  820. }