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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 界面编程 > Static控件 > 查看源码
CreditStatic.cpp
资源名称：credit_static_demo.zip　[点击查看]
上传用户：zhenlu1001
上传日期：2007-01-02
资源大小：131k
文件大小：28k
源码类别：

Static控件

开发平台：

Visual C++

CreditStatic.cpp：源码内容
  1. // CreditStatic.cpp : implementation file
  2. //
  4. #include "stdafx.h"
  5. #include "CreditStatic.h"
  7. #ifdef _DEBUG
  8. #define new DEBUG_NEW
  9. #undef THIS_FILE
  10. static char THIS_FILE[] = __FILE__;
  11. #endif
  13. #define  DISPLAY_TIMER_ID 150 // timer id
  14. /////////////////////////////////////////////////////////////////////////////
  15. // CCreditStatic
  17. CCreditStatic::CCreditStatic()
  18. {
  20. m_Colors[0] = RGB(0,0,0);       // Black
  21. m_Colors[1] = RGB(255,0,0);     // Red
  22. m_Colors[2] = RGB(255,255,0);   // Yellow
  23. m_Colors[3] = RGB(0,255,255);   // Turquoise
  24. m_Colors[4] = RGB(255,255,255); // White
  26. m_TextHeights[0] = 21;
  27. m_TextHeights[1] = 19;
  28. m_TextHeights[2] = 17;
  29. m_TextHeights[3] = 15;
  30. m_nCurrentFontHeight = m_TextHeights[NORMAL_TEXT_HEIGHT];
  33. m_Escapes[0] = 't';
  34. m_Escapes[1] = 'n';
  35. m_Escapes[2] = 'r';
  36. m_Escapes[3] = '^';
  38. m_DisplaySpeed[0] = 70;
  39. m_DisplaySpeed[1] = 40;
  40. m_DisplaySpeed[2] = 10;
  42. m_CurrentSpeed = 1;
  43. m_ScrollAmount = -1;
  44. m_bProcessingBitmap = FALSE;
  46. m_ArrIndex = NULL;
  47. m_nCounter = 1;
  48. m_nClip = 0;
  50. m_bFirstTime = TRUE;
  51. m_bDrawText = FALSE;
  52. m_bFirstTurn = TRUE;
  53. m_Gradient = GRADIENT_NONE;
  54. m_bTransparent = FALSE;
  55. n_MaxWidth = 0;
  56. TimerOn = 0;
  57. }
  59. CCreditStatic::~CCreditStatic()
  60. {
  61. }
  64. BEGIN_MESSAGE_MAP(CCreditStatic, CStatic)
  65. //{{AFX_MSG_MAP(CCreditStatic)
  66. ON_WM_PAINT()
  67. ON_WM_ERASEBKGND()
  68. ON_WM_TIMER()
  69. ON_WM_DESTROY()
  70. //}}AFX_MSG_MAP
  71. END_MESSAGE_MAP()
  73. /////////////////////////////////////////////////////////////////////////////
  74. // CCreditStatic message handlers
  76. BOOL CCreditStatic::StartScrolling()
  77. {
  78. if(m_ArrCredit.IsEmpty())
  79. return FALSE;
  81. if(m_BmpMain.m_hObject != NULL) {
  82. m_BmpMain.DeleteObject();
  83. m_BmpMain.m_hObject = NULL;
  84. }
  86. TimerOn = SetTimer(DISPLAY_TIMER_ID,m_DisplaySpeed[m_CurrentSpeed],NULL);
  87.     ASSERT(TimerOn != 0);
  89. m_ArrIndex = m_ArrCredit.GetHeadPosition();
  90. m_nCounter = 1;
  91. m_nClip = 0;
  93. m_bFirstTime = TRUE;
  94. m_bDrawText = FALSE;
  96. return TRUE;
  97. }
  99. void CCreditStatic::EndScrolling()
  100. {
  101. KillTimer(DISPLAY_TIMER_ID);
  102. TimerOn = 0;
  104. if(m_BmpMain.m_hObject != NULL) {
  105. m_BmpMain.DeleteObject();
  106. m_BmpMain.m_hObject = NULL;
  107. }
  108. }
  110. void CCreditStatic::SetCredits(LPCTSTR credits,char delimiter)
  111. {
  112. char *str,*ptr1,*ptr2;
  113.     
  114. ASSERT(credits);
  116. if((str = strdup(credits)) == NULL)
  117. return;
  119. m_ArrCredit.RemoveAll();
  121. ptr1 = str;
  122. while((ptr2 = strchr(ptr1,delimiter)) != NULL) {
  123. *ptr2 = '';
  124. m_ArrCredit.AddTail(ptr1);
  125. ptr1 = ptr2+1;
  126. }
  127. m_ArrCredit.AddTail(ptr1);
  129. free(str);
  131. m_ArrIndex = m_ArrCredit.GetHeadPosition();
  132. m_nCounter = 1;
  133. m_nClip = 0;
  135. m_bFirstTime = TRUE;
  136. m_bDrawText = FALSE;
  137. }
  139. void CCreditStatic::SetCredits(UINT nID,char delimiter)
  140. {
  141. CString credits;
  142. if(!credits.LoadString(nID))
  143. return;
  145. SetCredits((LPCTSTR)credits, delimiter);
  146. }
  148. void CCreditStatic::SetSpeed(UINT index, int speed)
  149. {
  150. ASSERT(index <= DISPLAY_FAST);
  152. if(speed)
  153. m_DisplaySpeed[index] = speed;
  155. m_CurrentSpeed = index;
  156. }
  158. void CCreditStatic::SetColor(UINT index, COLORREF col)
  159. {
  160. ASSERT(index <= NORMAL_TEXT_COLOR);
  162. m_Colors[index] = col;
  163. }
  165. void CCreditStatic::SetTextHeight(UINT index, int height)
  166. {
  167. ASSERT(index <= NORMAL_TEXT_HEIGHT);
  169. m_TextHeights[index] = height;
  170. }
  172. void CCreditStatic::SetEscape(UINT index, char escape)
  173. {
  174. ASSERT(index <= DISPLAY_BITMAP);
  176. m_Escapes[index] = escape;
  177. }
  179. void CCreditStatic::SetGradient(UINT value)
  180. {
  181. ASSERT(value <= GRADIENT_LEFT_LIGHT);
  183. m_Gradient = value;
  184. }
  186. void CCreditStatic::SetTransparent(BOOL bTransparent)
  187. {
  188. m_bTransparent = bTransparent;
  189. }
  191. void CCreditStatic::OnPaint() 
  192. {
  193. CPaintDC dc(this); // device context for painting
  195. if(TimerOn) return;
  197. CDC memDC;
  198. memDC.CreateCompatibleDC(&dc);
  200. CBitmap *pOldMemDCBitmap = NULL;
  201. CRect m_ScrollRect;
  202. GetClientRect(&m_ScrollRect);
  204. if(m_BmpMain.m_hObject == NULL) {
  206. CDC memDC2;
  207. CBitmap bitmap;
  208. memDC2.CreateCompatibleDC(&dc);
  209. bitmap.CreateCompatibleBitmap( &dc, m_ScrollRect.Width(), m_ScrollRect.Height() );
  210. CBitmap *pOldMemDC2Bitmap = (CBitmap*)memDC2.SelectObject(&bitmap);
  212. DrawCredit(&memDC2, m_ScrollRect);
  213. AddBackGround(&memDC2, m_ScrollRect, m_ScrollRect);
  215. pOldMemDCBitmap = (CBitmap*)memDC.SelectObject(&m_BmpMain);
  216.         memDC.BitBlt( 0, 0, m_ScrollRect.Width(), m_ScrollRect.Height(), 
  217.                                         &memDC2, 0, 0, SRCCOPY );
  218. memDC2.SelectObject(pOldMemDC2Bitmap);
  219. }
  220. else
  221. pOldMemDCBitmap = (CBitmap*)memDC.SelectObject(&m_BmpMain);
  222.        
  223. dc.BitBlt( 0, 0, m_ScrollRect.Width(), m_ScrollRect.Height(), 
  224.                &memDC, 0, 0, SRCCOPY );
  225. }
  227. BOOL CCreditStatic::OnEraseBkgnd(CDC* pDC) 
  228. {
  229. return TRUE;
  231. // return CStatic::OnEraseBkgnd(pDC);
  232. }
  234. //************************************************************************
  235. //  OnTimer
  236. //
  237. //   On each of the display timers, scroll the window 1 unit. Each 20
  238. //      units, fetch the next array element and load into work string. Call
  239. //      Invalidate and UpdateWindow to invoke the OnPaint which will paint 
  240. //      the contents of the newly updated work string.
  241. //************************************************************************
  242. void CCreditStatic::OnTimer(UINT nIDEvent) 
  243. {
  244. if (nIDEvent != DISPLAY_TIMER_ID)
  245. {
  246. CStatic::OnTimer(nIDEvent);
  247. return;
  248. }
  250. BOOL bCheck = FALSE;
  252. if (!m_bProcessingBitmap) {
  253. if (m_nCounter++ % m_nCurrentFontHeight == 0)  // every x timer events, show new line
  254. {
  255. m_nCounter=1;
  256. m_szWork = m_ArrCredit.GetNext(m_ArrIndex);
  257. if(m_bFirstTurn)
  258. bCheck = TRUE;
  259. if(m_ArrIndex == NULL) {
  260. m_bFirstTurn = FALSE;
  261. m_ArrIndex = m_ArrCredit.GetHeadPosition();
  262. }
  263. m_nClip = 0;
  264. m_bDrawText=TRUE;
  265. }
  266. }
  268.     CClientDC dc(this);
  269. CRect m_ScrollRect;
  270. GetClientRect(&m_ScrollRect);
  271.  
  272. CRect m_ClientRect(m_ScrollRect);
  273. m_ClientRect.left = (m_ClientRect.Width()-n_MaxWidth)/2;
  274. m_ClientRect.right = m_ClientRect.left + n_MaxWidth;
  276. MoveCredit(&dc, m_ScrollRect, m_ClientRect, bCheck);
  278. AddBackGround(&dc, m_ScrollRect, m_ClientRect);
  280. CStatic::OnTimer(nIDEvent);
  281. }
  283. void CCreditStatic::AddBackGround(CDC* pDC, CRect& m_ScrollRect, CRect& m_ClientRect)
  284. {
  285. CDC memDC;
  286. memDC.CreateCompatibleDC( pDC );
  288.     if( m_bitmap.m_hObject == NULL )
  289. {
  290.         CBitmap* pOldBitmap = memDC.SelectObject( &m_BmpMain );
  291.         pDC->BitBlt( 0, 0, m_ScrollRect.Width(), m_ScrollRect.Height(), 
  292.                                         &memDC, 0, 0, SRCCOPY );
  293. memDC.SelectObject(pOldBitmap);
  294. return;
  295. }
  297.    // Draw bitmap in the background if one has been set
  298.                 // Now create a mask
  299. CBitmap bitmap;
  300. bitmap.CreateCompatibleBitmap( pDC, m_ClientRect.Width(), m_ClientRect.Height() );
  301. CBitmap* pOldMemDCBitmap = memDC.SelectObject( &bitmap );
  303. CDC tempDC;
  304. tempDC.CreateCompatibleDC(pDC);
  305. CBitmap* pOldTempDCBitmap = tempDC.SelectObject( &m_BmpMain );
  307. memDC.BitBlt( 0, 0, m_ClientRect.Width(), m_ClientRect.Height(), &tempDC, 
  308.                       m_ClientRect.left, m_ClientRect.top, SRCCOPY );
  309. CDC maskDC;
  310. maskDC.CreateCompatibleDC(pDC);
  311. CBitmap maskBitmap;
  313. // Create monochrome bitmap for the mask
  314. maskBitmap.CreateBitmap( m_ClientRect.Width(), m_ClientRect.Height(), 1, 1, NULL );
  315. CBitmap* pOldMaskDCBitmap = maskDC.SelectObject( &maskBitmap );
  316.     memDC.SetBkColor(m_bTransparent? RGB(192,192,192): m_Colors[BACKGROUND_COLOR]);
  318. // Create the mask from the memory DC
  319. maskDC.BitBlt( 0, 0, m_ClientRect.Width(), m_ClientRect.Height(), &memDC, 0, 0, SRCCOPY );
  321. tempDC.SelectObject(pOldTempDCBitmap);
  322. pOldTempDCBitmap = tempDC.SelectObject( &m_bitmap );
  324. CDC imageDC;
  325. CBitmap bmpImage;
  326. imageDC.CreateCompatibleDC( pDC );
  327. bmpImage.CreateCompatibleBitmap( pDC, m_ScrollRect.Width(), m_ScrollRect.Height() );
  328. CBitmap* pOldImageDCBitmap = imageDC.SelectObject( &bmpImage );
  330. if( pDC->GetDeviceCaps(RASTERCAPS) & RC_PALETTE && m_pal.m_hObject != NULL )
  331. {
  332. pDC->SelectPalette( &m_pal, FALSE );
  333. pDC->RealizePalette();
  335. imageDC.SelectPalette( &m_pal, FALSE );
  336. }
  337. // Get x and y offset
  338. // Draw bitmap in tiled manner to imageDC
  339. for( int i = 0; i < m_ScrollRect.right; i += m_cxBitmap )
  340. for( int j = 0; j < m_ScrollRect.bottom; j += m_cyBitmap )
  341. imageDC.BitBlt( i, j, m_cxBitmap, m_cyBitmap, &tempDC, 0, 0, SRCCOPY );
  343. // Set the background in memDC to black. Using SRCPAINT with black and any other
  344. // color results in the other color, thus making black the transparent color
  345. memDC.SetBkColor(RGB(0,0,0));
  346. memDC.SetTextColor(RGB(255,255,255));
  347. memDC.BitBlt(0, 0, m_ClientRect.Width(), m_ClientRect.Height(), &maskDC, 0, 0, SRCAND);
  349. // Set the foreground to black. See comment above.
  350. imageDC.SetBkColor(RGB(255,255,255));
  351. imageDC.SetTextColor(RGB(0,0,0));
  352. imageDC.BitBlt(m_ClientRect.left, m_ClientRect.top, m_ClientRect.Width(), m_ClientRect.Height(), 
  353. &maskDC, 0, 0, SRCAND);
  355. // Combine the foreground with the background
  356.     imageDC.BitBlt(m_ClientRect.left, m_ClientRect.top, m_ClientRect.Width(), m_ClientRect.Height(), 
  357. &memDC, 0, 0,SRCPAINT);
  359. // Draw the final image to the screen   
  360. pDC->BitBlt( 0, 0, m_ScrollRect.Width(), m_ScrollRect.Height(), 
  361. &imageDC, 0, 0, SRCCOPY );
  363. imageDC.SelectObject(pOldImageDCBitmap);
  364. maskDC.SelectObject(pOldMaskDCBitmap);
  365. tempDC.SelectObject(pOldTempDCBitmap);
  366. memDC.SelectObject(pOldMemDCBitmap);
  367. }
  369. void CCreditStatic::DrawBitmap(CDC* pDC, CDC* pDC2, CRect *rBitmap)
  370. {
  371. if(!m_bTransparent || m_bitmap.m_hObject != NULL) {
  372.      pDC->BitBlt( rBitmap->left, rBitmap->top, rBitmap->Width(), rBitmap->Height(), 
  373.             pDC2, 0, 0, SRCCOPY );
  374. return;
  375. }
  377. CDC memDC;
  378. memDC.CreateCompatibleDC( pDC );
  380.     // Now create a mask
  381. CBitmap bitmap;
  382. bitmap.CreateCompatibleBitmap( pDC, rBitmap->Width(), rBitmap->Height() );
  383. CBitmap* pOldMemDCBitmap = memDC.SelectObject( &bitmap );
  385. memDC.BitBlt( 0, 0, rBitmap->Width(), rBitmap->Height(), pDC2, 0, 0, SRCCOPY );
  387. CDC maskDC;
  388. maskDC.CreateCompatibleDC(pDC);
  390. // Create monochrome bitmap for the mask
  391. CBitmap maskBitmap;
  392. maskBitmap.CreateBitmap( rBitmap->Width(), rBitmap->Height(), 1, 1, NULL );
  393. CBitmap* pOldMaskDCBitmap = maskDC.SelectObject( &maskBitmap );
  394.     memDC.SetBkColor(RGB(192,192,192));
  396. // Create the mask from the memory DC
  397. maskDC.BitBlt( 0, 0, rBitmap->Width(), rBitmap->Height(), &memDC, 0, 0, SRCCOPY );
  400. CDC imageDC;
  401. CBitmap bmpImage;
  402. imageDC.CreateCompatibleDC( pDC );
  403. bmpImage.CreateCompatibleBitmap( pDC, rBitmap->Width(), rBitmap->Height() );
  404. CBitmap* pOldImageDCBitmap = imageDC.SelectObject( &bmpImage );
  406. imageDC.BitBlt(0, 0, rBitmap->Width(), rBitmap->Height(), pDC, rBitmap->left, rBitmap->top, SRCCOPY);
  408. // Set the background in memDC to black. Using SRCPAINT with black and any other
  409. // color results in the other color, thus making black the transparent color
  410. memDC.SetBkColor(RGB(0,0,0));
  411. memDC.SetTextColor(RGB(255,255,255));
  412. memDC.BitBlt(0, 0, rBitmap->Width(), rBitmap->Height(), &maskDC, 0, 0, SRCAND);
  414. // Set the foreground to black. See comment above.
  415. imageDC.SetBkColor(RGB(255,255,255));
  416. imageDC.SetTextColor(RGB(0,0,0));
  417. imageDC.BitBlt(0, 0, rBitmap->Width(), rBitmap->Height(), &maskDC, 0, 0, SRCAND);
  419. // Combine the foreground with the background
  420.     imageDC.BitBlt(0, 0, rBitmap->Width(), rBitmap->Height(), &memDC, 0, 0,SRCPAINT);
  422. // Draw the final image to the screen   
  423. pDC->BitBlt( rBitmap->left, rBitmap->top, rBitmap->Width(), rBitmap->Height(), 
  424. &imageDC, 0, 0, SRCCOPY );
  426. imageDC.SelectObject(pOldImageDCBitmap);
  427. maskDC.SelectObject(pOldMaskDCBitmap);
  428. memDC.SelectObject(pOldMemDCBitmap);
  429. }
  431. void CCreditStatic::FillGradient(CDC *pDC, CRect *m_ScrollRect, CRect *m_FillRect, COLORREF color)
  432. { 
  433. float fStep,fRStep,fGStep,fBStep;     // How large is each band?
  434. int iOnBand;  // Loop index
  436. WORD R = GetRValue(color);
  437. WORD G = GetGValue(color);
  438. WORD B = GetBValue(color);
  440. // Determine how large each band should be in order to cover the
  441. // client with 256 bands (one for every color intensity level)
  442. if(m_Gradient % 2) {
  443. fRStep = (float)R / 255.0f;
  444. fGStep = (float)G / 255.0f;
  445. fBStep = (float)B / 255.0f;
  446. } else {
  447. fRStep = (float)(255-R) / 255.0f;
  448. fGStep = (float)(255-G) / 255.0f;
  449. fBStep = (float)(255-B) / 255.0f;
  450. }
  452. COLORREF OldCol = pDC->GetBkColor();
  453. // Start filling bands
  454. fStep = (float)m_ScrollRect->Width() / 256.0f;
  455. for(iOnBand = (256*m_FillRect->left)/m_ScrollRect->Width(); 
  456. (int)(iOnBand*fStep) < m_FillRect->right && iOnBand < 256; iOnBand++) {
  457. CRect r((int)(iOnBand * fStep), m_FillRect->top,
  458. (int)((iOnBand+1) * fStep), m_FillRect->bottom+1);
  459. COLORREF col;
  461. switch(m_Gradient) {
  462. case GRADIENT_RIGHT_DARK:
  463. col = RGB((int)(R-iOnBand*fRStep),(int)(G-iOnBand*fGStep),(int)(B-iOnBand*fBStep));
  464. break;
  465. case GRADIENT_RIGHT_LIGHT:
  466. col = RGB((int)(R+iOnBand*fRStep),(int)(G+iOnBand*fGStep),(int)(B+iOnBand*fBStep));
  467. break;
  468. case GRADIENT_LEFT_DARK:
  469. col = RGB((int)(iOnBand*fRStep),(int)(iOnBand*fGStep),(int)(iOnBand*fBStep));
  470. break;
  471. case GRADIENT_LEFT_LIGHT:
  472. col = RGB(255-(int)(iOnBand*fRStep),255-(int)(iOnBand*fGStep),255-(int)(iOnBand*fBStep));
  473. break;
  474. default:
  475. return;
  476. }
  477. pDC->FillSolidRect(&r, col);
  478. }
  479. pDC->SetBkColor(OldCol);
  480. } 
  482. #define SCROLLDC
  484. void CCreditStatic::MoveCredit(CDC* pDC, CRect& m_ScrollRect, CRect& m_ClientRect, BOOL bCheck)
  485. {
  486. CDC memDC,memDC2;
  487.     memDC.CreateCompatibleDC(pDC);
  488.     memDC2.CreateCompatibleDC(pDC);
  489.     
  490. COLORREF BackColor = (m_bTransparent && m_bitmap.m_hObject != NULL)? RGB(192,192,192) : m_Colors[BACKGROUND_COLOR];
  491. CBitmap *pOldMemDCBitmap = NULL;
  492. CBitmap *pOldMemDC2Bitmap = NULL;
  494. #ifdef SCROLLDC
  495. CRect r1;
  496. #endif
  498. if(m_BmpMain.m_hObject == NULL) {
  499. m_BmpMain.CreateCompatibleBitmap( pDC, m_ScrollRect.Width(), m_ScrollRect.Height() );
  500. pOldMemDCBitmap = (CBitmap*)memDC.SelectObject(&m_BmpMain);
  501. if(m_Gradient && m_bitmap.m_hObject == NULL)
  502. FillGradient(&memDC, &m_ScrollRect, &m_ScrollRect,m_Colors[BACKGROUND_COLOR]);
  503. else
  504. memDC.FillSolidRect(&m_ScrollRect,BackColor);
  505. } else 
  506. pOldMemDCBitmap = (CBitmap*)memDC.SelectObject(&m_BmpMain);
  508. if(m_ClientRect.Width() > 0) {
  509. #ifndef SCROLLDC
  510. CBitmap bitmap;
  511. bitmap.CreateCompatibleBitmap( pDC, m_ClientRect.Width(), m_ClientRect.Height() );
  512. pOldMemDC2Bitmap = memDC2.SelectObject(&bitmap);
  514. memDC2.BitBlt( 0, 0, m_ClientRect.Width(), m_ClientRect.Height()-abs(m_ScrollAmount), 
  515.              &memDC, m_ClientRect.left, abs(m_ScrollAmount), SRCCOPY );
  516. memDC.BitBlt( m_ClientRect.left, 0, m_ClientRect.Width(), m_ClientRect.Height(), 
  517.              &memDC2, 0, 0, SRCCOPY );
  520. memDC2.SelectObject(pOldMemDC2Bitmap);
  521. pOldMemDC2Bitmap = NULL;
  522. #else
  523. CRgn RgnUpdate;
  524. memDC.ScrollDC(0,m_ScrollAmount,(LPCRECT)m_ScrollRect,(LPCRECT)m_ClientRect,&RgnUpdate,
  525. (LPRECT)r1);
  526.     }
  527. else {
  528. r1 = m_ScrollRect;
  529. r1.top = r1.bottom-abs(m_ScrollAmount);
  530. #endif
  531. }
  533. m_nClip = m_nClip + abs(m_ScrollAmount);
  536. //*********************************************************************
  537. // FONT SELECTION
  538.     CFont m_fntArial;
  539. CFont* pOldFont = NULL;
  540. BOOL bSuccess = FALSE;
  542. BOOL bUnderline;
  543. BOOL bItalic;
  544.     int rmcode = 0;
  546. if (!m_szWork.IsEmpty()) {
  547. char c = m_szWork[m_szWork.GetLength()-1];
  548. if(c == m_Escapes[TOP_LEVEL_GROUP]) {
  549. rmcode = 1;
  550. bItalic = FALSE;
  551. bUnderline = FALSE;
  552. m_nCurrentFontHeight = m_TextHeights[TOP_LEVEL_GROUP_HEIGHT];
  553.     bSuccess = m_fntArial.CreateFont(m_TextHeights[TOP_LEVEL_GROUP_HEIGHT], 0, 0, 0, 
  554.     FW_BOLD, bItalic, bUnderline, 0, 
  555.     ANSI_CHARSET,
  556.                     OUT_DEFAULT_PRECIS,
  557.                     CLIP_DEFAULT_PRECIS,
  558.                     PROOF_QUALITY,
  559.                     VARIABLE_PITCH | 0x04 | FF_DONTCARE,
  560.                     (LPSTR)"Arial");
  561. memDC.SetTextColor(m_Colors[TOP_LEVEL_GROUP_COLOR]);
  562. if (pOldFont != NULL) memDC.SelectObject(pOldFont);
  563. pOldFont = memDC.SelectObject(&m_fntArial);
  565. }
  566. else if(c == m_Escapes[GROUP_TITLE]) {
  567. rmcode = 1;
  568. bItalic = FALSE;
  569. bUnderline = FALSE;
  570. m_nCurrentFontHeight = m_TextHeights[GROUP_TITLE_HEIGHT];
  571.     bSuccess = m_fntArial.CreateFont(m_TextHeights[GROUP_TITLE_HEIGHT], 0, 0, 0, 
  572.     FW_BOLD, bItalic, bUnderline, 0, 
  573.     ANSI_CHARSET,
  574.                     OUT_DEFAULT_PRECIS,
  575.                     CLIP_DEFAULT_PRECIS,
  576.                     PROOF_QUALITY,
  577.                     VARIABLE_PITCH | 0x04 | FF_DONTCARE,
  578.                     (LPSTR)"Arial");
  579. memDC.SetTextColor(m_Colors[GROUP_TITLE_COLOR]);
  580. if (pOldFont != NULL) memDC.SelectObject(pOldFont);
  581. pOldFont = memDC.SelectObject(&m_fntArial);
  582. }
  583. else if(c == m_Escapes[TOP_LEVEL_TITLE]) {
  584. rmcode = 1;
  585. bItalic = FALSE;
  586. // bUnderline = TRUE;
  587. bUnderline = FALSE;
  588. m_nCurrentFontHeight = m_TextHeights[TOP_LEVEL_TITLE_HEIGHT];
  589. bSuccess = m_fntArial.CreateFont(m_TextHeights[TOP_LEVEL_TITLE_HEIGHT], 0, 0, 0, 
  590. FW_BOLD, bItalic, bUnderline, 0, 
  591. ANSI_CHARSET,
  592.                 OUT_DEFAULT_PRECIS,
  593.                 CLIP_DEFAULT_PRECIS,
  594.                 PROOF_QUALITY,
  595.                 VARIABLE_PITCH | 0x04 | FF_DONTCARE,
  596.                 (LPSTR)"Arial");
  597. memDC.SetTextColor(m_Colors[TOP_LEVEL_TITLE_COLOR]);
  598. if (pOldFont != NULL) memDC.SelectObject(pOldFont);
  599. pOldFont = memDC.SelectObject(&m_fntArial);
  600. }
  601. else if(c == m_Escapes[DISPLAY_BITMAP]) {
  602. if (!m_bProcessingBitmap)
  603. {
  604. CString szBitmap = m_szWork.Left(m_szWork.GetLength()-1);
  605. if(m_bmpWork.LoadBitmap((const char *)szBitmap)) {
  606. BITMAP  m_bmpInfo;
  608.     m_bmpWork.GetObject(sizeof(BITMAP), &m_bmpInfo);
  610. m_size.cx = m_bmpInfo.bmWidth; // width  of dest rect
  611. m_size.cy = m_bmpInfo.bmHeight;
  612. // upper left point of dest
  613. m_pt.x = (m_ClientRect.right - 
  614. ((m_ClientRect.Width())/2) - (m_size.cx/2));
  615. m_pt.y = m_ClientRect.bottom;
  617. m_bProcessingBitmap = TRUE;
  618. if (pOldMemDC2Bitmap != NULL) memDC2.SelectObject(pOldMemDC2Bitmap);
  619. pOldMemDC2Bitmap = memDC2.SelectObject(&m_bmpWork);
  620. }
  621. else
  622. c = ' ';
  623. }
  624. else {
  625. if (pOldMemDC2Bitmap != NULL) memDC2.SelectObject(pOldMemDC2Bitmap);
  626. pOldMemDC2Bitmap = memDC2.SelectObject(&m_bmpWork);
  627. }
  628. }
  629. else {
  630. bItalic = FALSE;
  631. bUnderline = FALSE;
  632. m_nCurrentFontHeight = m_TextHeights[NORMAL_TEXT_HEIGHT];
  633.     bSuccess = m_fntArial.CreateFont(m_TextHeights[NORMAL_TEXT_HEIGHT], 0, 0, 0, 
  634.     FW_THIN, bItalic, bUnderline, 0, 
  635.     ANSI_CHARSET,
  636.                     OUT_DEFAULT_PRECIS,
  637.                     CLIP_DEFAULT_PRECIS,
  638.                     PROOF_QUALITY,
  639.                     VARIABLE_PITCH | 0x04 | FF_DONTCARE,
  640.                     (LPSTR)"Arial");
  641. memDC.SetTextColor(m_Colors[NORMAL_TEXT_COLOR]);
  642. if (pOldFont != NULL) memDC.SelectObject(pOldFont);
  643. pOldFont = memDC.SelectObject(&m_fntArial);
  644. }
  645. }
  647. #ifndef SCROLLDC
  648. CRect r1(m_ScrollRect);
  649. r1.top = r1.bottom-abs(m_ScrollAmount);
  650. #endif
  652. if(m_Gradient && m_bitmap.m_hObject == NULL)
  653. FillGradient(&memDC, &m_ScrollRect, &r1, m_Colors[BACKGROUND_COLOR]);
  654. else
  655. memDC.FillSolidRect(&r1,BackColor);
  656. memDC.SetBkMode(TRANSPARENT);
  658. if (!m_bProcessingBitmap)
  659. {
  660. if(bCheck) {
  661. CSize size = memDC.GetTextExtent((LPCTSTR)m_szWork,m_szWork.GetLength()-rmcode);
  662. if(size.cx > n_MaxWidth) {
  663. n_MaxWidth = (size.cx > m_ScrollRect.Width())? m_ScrollRect.Width():size.cx;
  664. m_ClientRect.left = (m_ScrollRect.Width()-n_MaxWidth)/2;
  665. m_ClientRect.right = m_ClientRect.left + n_MaxWidth;
  666. }
  668. }
  669. CRect r(m_ClientRect);
  670. r.top = r.bottom-m_nClip;
  671. int x = memDC.DrawText((const char *)m_szWork,m_szWork.GetLength()-rmcode,&r,DT_TOP|DT_CENTER|
  672. DT_NOPREFIX | DT_SINGLELINE);
  673. m_bDrawText=FALSE;
  674. }
  675. else
  676. {
  677. if(bCheck) {
  678. CSize size = memDC.GetTextExtent((LPCTSTR)m_szWork,m_szWork.GetLength()-rmcode);
  679. if(m_size.cx > n_MaxWidth) {
  680. n_MaxWidth = (m_size.cx > m_ScrollRect.Width())? m_ScrollRect.Width():m_size.cx;
  681. m_ClientRect.left = (m_ScrollRect.Width()-n_MaxWidth)/2;
  682. m_ClientRect.right = m_ClientRect.left + n_MaxWidth;
  683. }
  684. }
  685. CRect r( m_pt.x, m_pt.y-m_nClip, m_pt.x+ m_size.cx, m_pt.y);
  686. DrawBitmap(&memDC, &memDC2, &r);
  687. //     memDC.BitBlt( m_pt.x, m_pt.y-m_nClip, m_size.cx, m_nClip, 
  688. //            &memDC2, 0, 0, SRCCOPY );
  689. if (m_nClip >= m_size.cy)
  690. {
  691. m_bmpWork.DeleteObject();
  692. m_bProcessingBitmap = FALSE;
  693. m_nClip=0;
  694. m_szWork.Empty();
  695. m_nCounter=1;
  696. }
  697. }
  699. if (pOldMemDC2Bitmap != NULL) memDC2.SelectObject(pOldMemDC2Bitmap);
  700. if (pOldFont != NULL) memDC.SelectObject(pOldFont);
  701. memDC.SelectObject(pOldMemDCBitmap);
  702. }
  704. void CCreditStatic::DrawCredit(CDC* pDC, CRect& m_ScrollRect)
  705. {
  706. if(m_BmpMain.m_hObject != NULL) return;
  708. CDC memDC,memDC2;
  709.     memDC.CreateCompatibleDC(pDC);
  710.     memDC2.CreateCompatibleDC(pDC);
  711. COLORREF BackColor = (m_bTransparent && m_bitmap.m_hObject != NULL)? RGB(192,192,192) : m_Colors[BACKGROUND_COLOR];
  712.     
  713. CBitmap *pOldMemDCBitmap = NULL;
  715. m_BmpMain.CreateCompatibleBitmap( pDC, m_ScrollRect.Width(), m_ScrollRect.Height() );
  716. pOldMemDCBitmap = (CBitmap*)memDC.SelectObject(&m_BmpMain);
  718. if(m_Gradient && m_bitmap.m_hObject == NULL)
  719. FillGradient(&memDC, &m_ScrollRect, &m_ScrollRect, m_Colors[BACKGROUND_COLOR]);
  720. else
  721. memDC.FillSolidRect(&m_ScrollRect, BackColor);
  723. POSITION pos = m_ArrCredit.GetHeadPosition();
  724. int height = 0;
  725. while(pos != NULL && height <= m_ScrollRect.Height()) {
  726. CString m_szWork = m_ArrCredit.GetNext(pos);
  727. CFont m_fntArial;
  728. CFont *pOldFont = NULL;
  729. CBitmap *pOldMemDC2Bitmap = NULL;
  731. CDC memDC2;
  732. memDC2.CreateCompatibleDC(pDC);
  733. //*********************************************************************
  734. // FONT SELECTION
  737. BOOL bSuccess = FALSE;
  738. BOOL bIsBitmap = FALSE;
  740. BOOL bUnderline;
  741. BOOL bItalic;
  742. int rmcode = 0;
  743.         CBitmap bitmap;
  745. if (!m_szWork.IsEmpty()) {
  746. char c = m_szWork[m_szWork.GetLength()-1];
  747. if(c == m_Escapes[TOP_LEVEL_GROUP]) {
  748. rmcode = 1;
  749. bItalic = FALSE;
  750. bUnderline = FALSE;
  751. m_nCurrentFontHeight = m_TextHeights[TOP_LEVEL_GROUP_HEIGHT];
  752.     bSuccess = m_fntArial.CreateFont(m_TextHeights[TOP_LEVEL_GROUP_HEIGHT], 0, 0, 0, 
  753.     FW_BOLD, bItalic, bUnderline, 0, 
  754.     ANSI_CHARSET,
  755.                     OUT_DEFAULT_PRECIS,
  756.                     CLIP_DEFAULT_PRECIS,
  757.                     PROOF_QUALITY,
  758.                     VARIABLE_PITCH | 0x04 | FF_DONTCARE,
  759.                     (LPSTR)"Arial");
  760. memDC.SetTextColor(m_Colors[TOP_LEVEL_GROUP_COLOR]);
  761. pOldFont = memDC.SelectObject(&m_fntArial);
  763. }
  764. else if(c == m_Escapes[GROUP_TITLE]) {
  765. rmcode = 1;
  766. bItalic = FALSE;
  767. bUnderline = FALSE;
  768. m_nCurrentFontHeight = m_TextHeights[GROUP_TITLE_HEIGHT];
  769.     bSuccess = m_fntArial.CreateFont(m_TextHeights[GROUP_TITLE_HEIGHT], 0, 0, 0, 
  770.     FW_BOLD, bItalic, bUnderline, 0, 
  771.     ANSI_CHARSET,
  772.                     OUT_DEFAULT_PRECIS,
  773.                     CLIP_DEFAULT_PRECIS,
  774.                     PROOF_QUALITY,
  775.                     VARIABLE_PITCH | 0x04 | FF_DONTCARE,
  776.                     (LPSTR)"Arial");
  777. memDC.SetTextColor(m_Colors[GROUP_TITLE_COLOR]);
  778. pOldFont = memDC.SelectObject(&m_fntArial);
  779. }
  780. else if(c == m_Escapes[TOP_LEVEL_TITLE]) {
  781. rmcode = 1;
  782. bItalic = FALSE;
  783. // bUnderline = TRUE;
  784. bUnderline = FALSE;
  785. m_nCurrentFontHeight = m_TextHeights[TOP_LEVEL_TITLE_HEIGHT];
  786. bSuccess = m_fntArial.CreateFont(m_TextHeights[TOP_LEVEL_TITLE_HEIGHT], 0, 0, 0, 
  787. FW_BOLD, bItalic, bUnderline, 0, 
  788. ANSI_CHARSET,
  789.                 OUT_DEFAULT_PRECIS,
  790.                 CLIP_DEFAULT_PRECIS,
  791.                 PROOF_QUALITY,
  792.                 VARIABLE_PITCH | 0x04 | FF_DONTCARE,
  793.                 (LPSTR)"Arial");
  794. memDC.SetTextColor(m_Colors[TOP_LEVEL_TITLE_COLOR]);
  795. pOldFont = memDC.SelectObject(&m_fntArial);
  796. }
  797. else if(c == m_Escapes[DISPLAY_BITMAP]) {
  798. CString szBitmap = m_szWork.Left(m_szWork.GetLength()-1);
  799. if(bitmap.LoadBitmap((const char *)szBitmap)) {
  800. BITMAP  m_bmpInfo;
  802.     bitmap.GetObject(sizeof(BITMAP), &m_bmpInfo);
  804. m_size.cx = m_bmpInfo.bmWidth; // width  of dest rect
  805. m_size.cy = m_bmpInfo.bmHeight;
  806. // upper left point of dest
  807. m_pt.x = (m_ScrollRect.right - 
  808. ((m_ScrollRect.Width())/2) - (m_size.cx/2));
  809. m_pt.y = height;
  810. pOldMemDC2Bitmap = memDC2.SelectObject(&bitmap);
  811. bIsBitmap = TRUE;
  812. }
  813. else
  814. c = ' ';
  815. }
  816. else {
  817. bItalic = FALSE;
  818. bUnderline = FALSE;
  819. m_nCurrentFontHeight = m_TextHeights[NORMAL_TEXT_HEIGHT];
  820.     bSuccess = m_fntArial.CreateFont(m_TextHeights[NORMAL_TEXT_HEIGHT], 0, 0, 0, 
  821.     FW_THIN, bItalic, bUnderline, 0, 
  822.     ANSI_CHARSET,
  823.                     OUT_DEFAULT_PRECIS,
  824.                     CLIP_DEFAULT_PRECIS,
  825.                     PROOF_QUALITY,
  826.                     VARIABLE_PITCH | 0x04 | FF_DONTCARE,
  827.                     (LPSTR)"Arial");
  828. memDC.SetTextColor(m_Colors[NORMAL_TEXT_COLOR]);
  829. pOldFont = memDC.SelectObject(&m_fntArial);
  830. }
  831. }
  833. memDC.SetBkMode(TRANSPARENT);
  835. if (!bIsBitmap)
  836. {
  837. CRect r(m_ScrollRect);
  838. r.top = height;
  839. CSize size;
  840. if(m_szWork.GetLength()-rmcode != 0) 
  841. {
  842. int x = memDC.DrawText((const char *)m_szWork,m_szWork.GetLength()-rmcode,&r,DT_TOP|DT_CENTER|
  843. DT_NOPREFIX | DT_SINGLELINE);
  844. size = memDC.GetTextExtent((LPCTSTR)m_szWork,m_szWork.GetLength()-rmcode);
  845. }
  846. else
  847. size = memDC.GetTextExtent((LPCTSTR)"W",1);
  848. height += size.cy;
  849. }
  850. else
  851. {
  852. CRect r( m_pt.x, m_pt.y, m_pt.x + m_size.cx, m_pt.y + m_size.cy);
  853. DrawBitmap(&memDC, &memDC2, &r);
  854. //     memDC.BitBlt( m_pt.x, m_pt.y, m_size.cx, m_size.cy, &memDC2, 0, 0, SRCCOPY );
  855. height += m_size.cy;
  856. }
  857. if (pOldMemDC2Bitmap != NULL) memDC2.SelectObject(pOldMemDC2Bitmap);
  858. if (pOldFont != NULL) memDC.SelectObject(pOldFont);
  859. }
  860. memDC.SelectObject(pOldMemDCBitmap);
  861. }
  863. void CCreditStatic::OnDestroy() 
  864. {
  865. CStatic::OnDestroy();
  867. m_ArrCredit.RemoveAll();
  869. if(TimerOn)
  870. ASSERT(KillTimer(DISPLAY_TIMER_ID));
  871. }
  873. BOOL CCreditStatic::SetBkImage(UINT nIDResource)
  874. {
  875.     return SetBkImage( (LPCTSTR)nIDResource );
  876. }
  878. BOOL CCreditStatic::SetBkImage(LPCTSTR lpszResourceName)
  879. {
  881.     // If this is not the first call then Delete GDI objects
  882.     if( m_bitmap.m_hObject != NULL )
  883. m_bitmap.DeleteObject();
  884.     if( m_pal.m_hObject != NULL )
  885. m_pal.DeleteObject();
  886.     
  887.     
  888.     HBITMAP hBmp = (HBITMAP)::LoadImage( AfxGetInstanceHandle(), 
  889.             lpszResourceName, IMAGE_BITMAP, 0,0, LR_CREATEDIBSECTION );
  891.      if( hBmp == NULL ) 
  892.         return FALSE;
  894. m_bitmap.Attach( hBmp );
  895.     BITMAP bm;
  896.     m_bitmap.GetBitmap( &bm );
  897.     m_cxBitmap = bm.bmWidth;
  898.     m_cyBitmap = bm.bmHeight;
  900.     // Create a logical palette for the bitmap
  901.     DIBSECTION ds;
  902.     BITMAPINFOHEADER &bmInfo = ds.dsBmih;
  903.     m_bitmap.GetObject( sizeof(ds), &ds );
  905.     int nColors = bmInfo.biClrUsed ? bmInfo.biClrUsed : 1 << bmInfo.biBitCount;
  907.     // Create a halftone palette if colors > 256. 
  908.     CClientDC dc(NULL);             // Desktop DC
  909.     if( nColors > 256 )
  910.         m_pal.CreateHalftonePalette( &dc );
  911.     else
  912.     {
  913.         // Create the palette
  915.         RGBQUAD *pRGB = new RGBQUAD[nColors];
  916.         CDC memDC;
  917.         memDC.CreateCompatibleDC(&dc);
  919.         CBitmap* pOldMemDCBitmap = memDC.SelectObject( &m_bitmap );
  920.         ::GetDIBColorTable( memDC, 0, nColors, pRGB );
  922.         UINT nSize = sizeof(LOGPALETTE) + (sizeof(PALETTEENTRY) * nColors);
  923.         LOGPALETTE *pLP = (LOGPALETTE *) new BYTE[nSize];
  925.         pLP->palVersion = 0x300;
  926.         pLP->palNumEntries = nColors;
  928.         for( int i=0; i < nColors; i++)
  929.         {
  930.             pLP->palPalEntry[i].peRed = pRGB[i].rgbRed;
  931.             pLP->palPalEntry[i].peGreen = pRGB[i].rgbGreen;
  932.             pLP->palPalEntry[i].peBlue = pRGB[i].rgbBlue;
  933.             pLP->palPalEntry[i].peFlags = 0;
  934.         }
  936.         m_pal.CreatePalette( pLP );
  938. memDC.SelectObject(pOldMemDCBitmap);
  939.         delete[] pLP;
  940.         delete[] pRGB;
  941.     }
  942. //    Invalidate();
  944.     return TRUE;
  945. }