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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 射击游戏 > 查看源码
CREDITSTATIC.CPP
资源名称：Fly ight.zip　[点击查看]
上传用户：baina_li
上传日期：2013-03-23
资源大小：960k
文件大小：28k
源码类别：

射击游戏

开发平台：

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(0,255,0);   // Yellow
  23. m_Colors[3] = RGB(0, 255, 255);   // Turquoise
  24. m_Colors[4] = RGB(0, 0, 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. //以下由王文利Modified--UNDO
  340. imageDC.StretchBlt(0, 0, m_ScrollRect.right, m_ScrollRect.bottom,
  341. &tempDC, 0, 0, m_cxBitmap, m_cyBitmap, SRCCOPY );
  342. // for( int i = 0; i < m_ScrollRect.right; i += m_cxBitmap )
  343. // for( int j = 0; j < m_ScrollRect.bottom; j += m_cyBitmap )
  344. // imageDC.BitBlt( i, j, m_cxBitmap, m_cyBitmap, &tempDC, 0, 0, SRCCOPY );
  346. // Set the background in memDC to black. Using SRCPAINT with black and any other
  347. // color results in the other color, thus making black the transparent color
  348. memDC.SetBkColor(RGB(0,0,0));
  349. memDC.SetTextColor(RGB(255,255,255));
  350. memDC.BitBlt(0, 0, m_ClientRect.Width(), m_ClientRect.Height(), &maskDC, 0, 0, SRCAND);
  352. // Set the foreground to black. See comment above.
  353. imageDC.SetBkColor(RGB(255,255,255));
  354. imageDC.SetTextColor(RGB(0,0,0));
  355. imageDC.BitBlt(m_ClientRect.left, m_ClientRect.top, m_ClientRect.Width(), m_ClientRect.Height(), 
  356. &maskDC, 0, 0, SRCAND);
  358. // Combine the foreground with the background
  359.     imageDC.BitBlt(m_ClientRect.left, m_ClientRect.top, m_ClientRect.Width(), m_ClientRect.Height(), 
  360. &memDC, 0, 0,SRCPAINT);
  362. // Draw the final image to the screen   
  363. pDC->BitBlt( 0, 0, m_ScrollRect.Width(), m_ScrollRect.Height(), 
  364. &imageDC, 0, 0, SRCCOPY );
  366. imageDC.SelectObject(pOldImageDCBitmap);
  367. maskDC.SelectObject(pOldMaskDCBitmap);
  368. tempDC.SelectObject(pOldTempDCBitmap);
  369. memDC.SelectObject(pOldMemDCBitmap);
  370. }
  372. void CCreditStatic::DrawBitmap(CDC* pDC, CDC* pDC2, CRect *rBitmap)
  373. {
  374. if(!m_bTransparent || m_bitmap.m_hObject != NULL) {
  375.      pDC->BitBlt( rBitmap->left, rBitmap->top, rBitmap->Width(), rBitmap->Height(), 
  376.             pDC2, 0, 0, SRCCOPY );
  377. return;
  378. }
  380. CDC memDC;
  381. memDC.CreateCompatibleDC( pDC );
  383.     // Now create a mask
  384. CBitmap bitmap;
  385. bitmap.CreateCompatibleBitmap( pDC, rBitmap->Width(), rBitmap->Height() );
  386. CBitmap* pOldMemDCBitmap = memDC.SelectObject( &bitmap );
  388. memDC.BitBlt( 0, 0, rBitmap->Width(), rBitmap->Height(), pDC2, 0, 0, SRCCOPY );
  390. CDC maskDC;
  391. maskDC.CreateCompatibleDC(pDC);
  393. // Create monochrome bitmap for the mask
  394. CBitmap maskBitmap;
  395. maskBitmap.CreateBitmap( rBitmap->Width(), rBitmap->Height(), 1, 1, NULL );
  396. CBitmap* pOldMaskDCBitmap = maskDC.SelectObject( &maskBitmap );
  397.     memDC.SetBkColor(RGB(192,192,192));
  399. // Create the mask from the memory DC
  400. maskDC.BitBlt( 0, 0, rBitmap->Width(), rBitmap->Height(), &memDC, 0, 0, SRCCOPY );
  403. CDC imageDC;
  404. CBitmap bmpImage;
  405. imageDC.CreateCompatibleDC( pDC );
  406. bmpImage.CreateCompatibleBitmap( pDC, rBitmap->Width(), rBitmap->Height() );
  407. CBitmap* pOldImageDCBitmap = imageDC.SelectObject( &bmpImage );
  409. imageDC.BitBlt(0, 0, rBitmap->Width(), rBitmap->Height(), pDC, rBitmap->left, rBitmap->top, SRCCOPY);
  411. // Set the background in memDC to black. Using SRCPAINT with black and any other
  412. // color results in the other color, thus making black the transparent color
  413. memDC.SetBkColor(RGB(0,0,0));
  414. memDC.SetTextColor(RGB(255,255,255));
  415. memDC.BitBlt(0, 0, rBitmap->Width(), rBitmap->Height(), &maskDC, 0, 0, SRCAND);
  417. // Set the foreground to black. See comment above.
  418. imageDC.SetBkColor(RGB(255,255,255));
  419. imageDC.SetTextColor(RGB(0,0,0));
  420. imageDC.BitBlt(0, 0, rBitmap->Width(), rBitmap->Height(), &maskDC, 0, 0, SRCAND);
  422. // Combine the foreground with the background
  423.     imageDC.BitBlt(0, 0, rBitmap->Width(), rBitmap->Height(), &memDC, 0, 0,SRCPAINT);
  425. // Draw the final image to the screen   
  426. pDC->BitBlt( rBitmap->left, rBitmap->top, rBitmap->Width(), rBitmap->Height(), 
  427. &imageDC, 0, 0, SRCCOPY );
  429. imageDC.SelectObject(pOldImageDCBitmap);
  430. maskDC.SelectObject(pOldMaskDCBitmap);
  431. memDC.SelectObject(pOldMemDCBitmap);
  432. }
  434. void CCreditStatic::FillGradient(CDC *pDC, CRect *m_ScrollRect, CRect *m_FillRect, COLORREF color)
  435. { 
  436. float fStep,fRStep,fGStep,fBStep;     // How large is each band?
  437. int iOnBand;  // Loop index
  439. WORD R = GetRValue(color);
  440. WORD G = GetGValue(color);
  441. WORD B = GetBValue(color);
  443. // Determine how large each band should be in order to cover the
  444. // client with 256 bands (one for every color intensity level)
  445. if(m_Gradient % 2) {
  446. fRStep = (float)R / 255.0f;
  447. fGStep = (float)G / 255.0f;
  448. fBStep = (float)B / 255.0f;
  449. } else {
  450. fRStep = (float)(255-R) / 255.0f;
  451. fGStep = (float)(255-G) / 255.0f;
  452. fBStep = (float)(255-B) / 255.0f;
  453. }
  455. COLORREF OldCol = pDC->GetBkColor();
  456. // Start filling bands
  457. fStep = (float)m_ScrollRect->Width() / 256.0f;
  458. for(iOnBand = (256*m_FillRect->left)/m_ScrollRect->Width(); 
  459. (int)(iOnBand*fStep) < m_FillRect->right && iOnBand < 256; iOnBand++) {
  460. CRect r((int)(iOnBand * fStep), m_FillRect->top,
  461. (int)((iOnBand+1) * fStep), m_FillRect->bottom+1);
  462. COLORREF col;
  464. switch(m_Gradient) {
  465. case GRADIENT_RIGHT_DARK:
  466. col = RGB((int)(R-iOnBand*fRStep),(int)(G-iOnBand*fGStep),(int)(B-iOnBand*fBStep));
  467. break;
  468. case GRADIENT_RIGHT_LIGHT:
  469. col = RGB((int)(R+iOnBand*fRStep),(int)(G+iOnBand*fGStep),(int)(B+iOnBand*fBStep));
  470. break;
  471. case GRADIENT_LEFT_DARK:
  472. col = RGB((int)(iOnBand*fRStep),(int)(iOnBand*fGStep),(int)(iOnBand*fBStep));
  473. break;
  474. case GRADIENT_LEFT_LIGHT:
  475. col = RGB(255-(int)(iOnBand*fRStep),255-(int)(iOnBand*fGStep),255-(int)(iOnBand*fBStep));
  476. break;
  477. default:
  478. return;
  479. }
  480. pDC->FillSolidRect(&r, col);
  481. }
  482. pDC->SetBkColor(OldCol);
  483. } 
  485. #define SCROLLDC
  487. void CCreditStatic::MoveCredit(CDC* pDC, CRect& m_ScrollRect, CRect& m_ClientRect, BOOL bCheck)
  488. {
  489. CDC memDC,memDC2;
  490.     memDC.CreateCompatibleDC(pDC);
  491.     memDC2.CreateCompatibleDC(pDC);
  492.     
  493. COLORREF BackColor = (m_bTransparent && m_bitmap.m_hObject != NULL)? RGB(192,192,192) : m_Colors[BACKGROUND_COLOR];
  494. CBitmap *pOldMemDCBitmap = NULL;
  495. CBitmap *pOldMemDC2Bitmap = NULL;
  497. #ifdef SCROLLDC
  498. CRect r1;
  499. #endif
  501. if(m_BmpMain.m_hObject == NULL) {
  502. m_BmpMain.CreateCompatibleBitmap( pDC, m_ScrollRect.Width(), m_ScrollRect.Height() );
  503. pOldMemDCBitmap = (CBitmap*)memDC.SelectObject(&m_BmpMain);
  504. if(m_Gradient && m_bitmap.m_hObject == NULL)
  505. FillGradient(&memDC, &m_ScrollRect, &m_ScrollRect,m_Colors[BACKGROUND_COLOR]);
  506. else
  507. memDC.FillSolidRect(&m_ScrollRect,BackColor);
  508. } else 
  509. pOldMemDCBitmap = (CBitmap*)memDC.SelectObject(&m_BmpMain);
  511. if(m_ClientRect.Width() > 0) {
  512. #ifndef SCROLLDC
  513. CBitmap bitmap;
  514. bitmap.CreateCompatibleBitmap( pDC, m_ClientRect.Width(), m_ClientRect.Height() );
  515. pOldMemDC2Bitmap = memDC2.SelectObject(&bitmap);
  517. memDC2.BitBlt( 0, 0, m_ClientRect.Width(), m_ClientRect.Height()-abs(m_ScrollAmount), 
  518.              &memDC, m_ClientRect.left, abs(m_ScrollAmount), SRCCOPY );
  519. memDC.BitBlt( m_ClientRect.left, 0, m_ClientRect.Width(), m_ClientRect.Height(), 
  520.              &memDC2, 0, 0, SRCCOPY );
  523. memDC2.SelectObject(pOldMemDC2Bitmap);
  524. pOldMemDC2Bitmap = NULL;
  525. #else
  526. CRgn RgnUpdate;
  527. memDC.ScrollDC(0,m_ScrollAmount,(LPCRECT)m_ScrollRect,(LPCRECT)m_ClientRect,&RgnUpdate,
  528. (LPRECT)r1);
  529.     }
  530. else {
  531. r1 = m_ScrollRect;
  532. r1.top = r1.bottom-abs(m_ScrollAmount);
  533. #endif
  534. }
  536. m_nClip = m_nClip + abs(m_ScrollAmount);
  539. //*********************************************************************
  540. // FONT SELECTION
  541.     CFont m_fntArial;
  542. CFont* pOldFont = NULL;
  543. BOOL bSuccess = FALSE;
  545. BOOL bUnderline;
  546. BOOL bItalic;
  547.     int rmcode = 0;
  549. if (!m_szWork.IsEmpty()) {
  550. char c = m_szWork[m_szWork.GetLength()-1];
  551. if(c == m_Escapes[TOP_LEVEL_GROUP]) {
  552. rmcode = 1;
  553. bItalic = FALSE;
  554. bUnderline = FALSE;
  555. m_nCurrentFontHeight = m_TextHeights[TOP_LEVEL_GROUP_HEIGHT];
  556.     bSuccess = m_fntArial.CreateFont(m_TextHeights[TOP_LEVEL_GROUP_HEIGHT], 0, 0, 0, 
  557.     FW_BOLD, bItalic, bUnderline, 0, 
  558.     ANSI_CHARSET,
  559.                     OUT_DEFAULT_PRECIS,
  560.                     CLIP_DEFAULT_PRECIS,
  561.                     PROOF_QUALITY,
  562.                     VARIABLE_PITCH | 0x04 | FF_DONTCARE,
  563.                     (LPSTR)"Arial");
  564. memDC.SetTextColor(m_Colors[TOP_LEVEL_GROUP_COLOR]);
  565. if (pOldFont != NULL) memDC.SelectObject(pOldFont);
  566. pOldFont = memDC.SelectObject(&m_fntArial);
  568. }
  569. else if(c == m_Escapes[GROUP_TITLE]) {
  570. rmcode = 1;
  571. bItalic = FALSE;
  572. bUnderline = FALSE;
  573. m_nCurrentFontHeight = m_TextHeights[GROUP_TITLE_HEIGHT];
  574.     bSuccess = m_fntArial.CreateFont(m_TextHeights[GROUP_TITLE_HEIGHT], 0, 0, 0, 
  575.     FW_BOLD, bItalic, bUnderline, 0, 
  576.     ANSI_CHARSET,
  577.                     OUT_DEFAULT_PRECIS,
  578.                     CLIP_DEFAULT_PRECIS,
  579.                     PROOF_QUALITY,
  580.                     VARIABLE_PITCH | 0x04 | FF_DONTCARE,
  581.                     (LPSTR)"Arial");
  582. memDC.SetTextColor(m_Colors[GROUP_TITLE_COLOR]);
  583. if (pOldFont != NULL) memDC.SelectObject(pOldFont);
  584. pOldFont = memDC.SelectObject(&m_fntArial);
  585. }
  586. else if(c == m_Escapes[TOP_LEVEL_TITLE]) {
  587. rmcode = 1;
  588. bItalic = FALSE;
  589. // bUnderline = TRUE;
  590. bUnderline = FALSE;
  591. m_nCurrentFontHeight = m_TextHeights[TOP_LEVEL_TITLE_HEIGHT];
  592. bSuccess = m_fntArial.CreateFont(m_TextHeights[TOP_LEVEL_TITLE_HEIGHT], 0, 0, 0, 
  593. FW_BOLD, bItalic, bUnderline, 0, 
  594. ANSI_CHARSET,
  595.                 OUT_DEFAULT_PRECIS,
  596.                 CLIP_DEFAULT_PRECIS,
  597.                 PROOF_QUALITY,
  598.                 VARIABLE_PITCH | 0x04 | FF_DONTCARE,
  599.                 (LPSTR)"Arial");
  600. memDC.SetTextColor(m_Colors[TOP_LEVEL_TITLE_COLOR]);
  601. if (pOldFont != NULL) memDC.SelectObject(pOldFont);
  602. pOldFont = memDC.SelectObject(&m_fntArial);
  603. }
  604. else if(c == m_Escapes[DISPLAY_BITMAP]) {
  605. if (!m_bProcessingBitmap)
  606. {
  607. CString szBitmap = m_szWork.Left(m_szWork.GetLength()-1);
  608. if(m_bmpWork.LoadBitmap((const char *)szBitmap)) {
  609. BITMAP  m_bmpInfo;
  611.     m_bmpWork.GetObject(sizeof(BITMAP), &m_bmpInfo);
  613. m_size.cx = m_bmpInfo.bmWidth; // width  of dest rect
  614. m_size.cy = m_bmpInfo.bmHeight;
  615. // upper left point of dest
  616. m_pt.x = (m_ClientRect.right - 
  617. ((m_ClientRect.Width())/2) - (m_size.cx/2));
  618. m_pt.y = m_ClientRect.bottom;
  620. m_bProcessingBitmap = TRUE;
  621. if (pOldMemDC2Bitmap != NULL) memDC2.SelectObject(pOldMemDC2Bitmap);
  622. pOldMemDC2Bitmap = memDC2.SelectObject(&m_bmpWork);
  623. }
  624. else
  625. c = ' ';
  626. }
  627. else {
  628. if (pOldMemDC2Bitmap != NULL) memDC2.SelectObject(pOldMemDC2Bitmap);
  629. pOldMemDC2Bitmap = memDC2.SelectObject(&m_bmpWork);
  630. }
  631. }
  632. else {
  633. bItalic = FALSE;
  634. bUnderline = FALSE;
  635. m_nCurrentFontHeight = m_TextHeights[NORMAL_TEXT_HEIGHT];
  636.     bSuccess = m_fntArial.CreateFont(m_TextHeights[NORMAL_TEXT_HEIGHT], 0, 0, 0, 
  637.     FW_THIN, bItalic, bUnderline, 0, 
  638.     ANSI_CHARSET,
  639.                     OUT_DEFAULT_PRECIS,
  640.                     CLIP_DEFAULT_PRECIS,
  641.                     PROOF_QUALITY,
  642.                     VARIABLE_PITCH | 0x04 | FF_DONTCARE,
  643.                     (LPSTR)"Arial");
  644. memDC.SetTextColor(m_Colors[NORMAL_TEXT_COLOR]);
  645. if (pOldFont != NULL) memDC.SelectObject(pOldFont);
  646. pOldFont = memDC.SelectObject(&m_fntArial);
  647. }
  648. }
  650. #ifndef SCROLLDC
  651. CRect r1(m_ScrollRect);
  652. r1.top = r1.bottom-abs(m_ScrollAmount);
  653. #endif
  655. if(m_Gradient && m_bitmap.m_hObject == NULL)
  656. FillGradient(&memDC, &m_ScrollRect, &r1, m_Colors[BACKGROUND_COLOR]);
  657. else
  658. memDC.FillSolidRect(&r1,BackColor);
  659. memDC.SetBkMode(TRANSPARENT);
  661. if (!m_bProcessingBitmap)
  662. {
  663. if(bCheck) {
  664. CSize size = memDC.GetTextExtent((LPCTSTR)m_szWork,m_szWork.GetLength()-rmcode);
  665. if(size.cx > n_MaxWidth) {
  666. n_MaxWidth = (size.cx > m_ScrollRect.Width())? m_ScrollRect.Width():size.cx;
  667. m_ClientRect.left = (m_ScrollRect.Width()-n_MaxWidth)/2;
  668. m_ClientRect.right = m_ClientRect.left + n_MaxWidth;
  669. }
  671. }
  672. CRect r(m_ClientRect);
  673. r.top = r.bottom-m_nClip;
  674. int x = memDC.DrawText((const char *)m_szWork,m_szWork.GetLength()-rmcode,&r,DT_TOP|DT_CENTER|
  675. DT_NOPREFIX | DT_SINGLELINE);
  676. m_bDrawText=FALSE;
  677. }
  678. else
  679. {
  680. if(bCheck) {
  681. CSize size = memDC.GetTextExtent((LPCTSTR)m_szWork,m_szWork.GetLength()-rmcode);
  682. if(m_size.cx > n_MaxWidth) {
  683. n_MaxWidth = (m_size.cx > m_ScrollRect.Width())? m_ScrollRect.Width():m_size.cx;
  684. m_ClientRect.left = (m_ScrollRect.Width()-n_MaxWidth)/2;
  685. m_ClientRect.right = m_ClientRect.left + n_MaxWidth;
  686. }
  687. }
  688. CRect r( m_pt.x, m_pt.y-m_nClip, m_pt.x+ m_size.cx, m_pt.y);
  689. DrawBitmap(&memDC, &memDC2, &r);
  690. //     memDC.BitBlt( m_pt.x, m_pt.y-m_nClip, m_size.cx, m_nClip, 
  691. //            &memDC2, 0, 0, SRCCOPY );
  692. if (m_nClip >= m_size.cy)
  693. {
  694. m_bmpWork.DeleteObject();
  695. m_bProcessingBitmap = FALSE;
  696. m_nClip=0;
  697. m_szWork.Empty();
  698. m_nCounter=1;
  699. }
  700. }
  702. if (pOldMemDC2Bitmap != NULL) memDC2.SelectObject(pOldMemDC2Bitmap);
  703. if (pOldFont != NULL) memDC.SelectObject(pOldFont);
  704. memDC.SelectObject(pOldMemDCBitmap);
  705. }
  707. void CCreditStatic::DrawCredit(CDC* pDC, CRect& m_ScrollRect)
  708. {
  709. if(m_BmpMain.m_hObject != NULL) return;
  711. CDC memDC,memDC2;
  712.     memDC.CreateCompatibleDC(pDC);
  713.     memDC2.CreateCompatibleDC(pDC);
  714. COLORREF BackColor = (m_bTransparent && m_bitmap.m_hObject != NULL)? RGB(192,192,192) : m_Colors[BACKGROUND_COLOR];
  715.     
  716. CBitmap *pOldMemDCBitmap = NULL;
  718. m_BmpMain.CreateCompatibleBitmap( pDC, m_ScrollRect.Width(), m_ScrollRect.Height() );
  719. pOldMemDCBitmap = (CBitmap*)memDC.SelectObject(&m_BmpMain);
  721. if(m_Gradient && m_bitmap.m_hObject == NULL)
  722. FillGradient(&memDC, &m_ScrollRect, &m_ScrollRect, m_Colors[BACKGROUND_COLOR]);
  723. else
  724. memDC.FillSolidRect(&m_ScrollRect, BackColor);
  726. POSITION pos = m_ArrCredit.GetHeadPosition();
  727. int height = 0;
  728. while(pos != NULL && height <= m_ScrollRect.Height()) {
  729. CString m_szWork = m_ArrCredit.GetNext(pos);
  730. CFont m_fntArial;
  731. CFont *pOldFont = NULL;
  732. CBitmap *pOldMemDC2Bitmap = NULL;
  734. CDC memDC2;
  735. memDC2.CreateCompatibleDC(pDC);
  736. //*********************************************************************
  737. // FONT SELECTION
  740. BOOL bSuccess = FALSE;
  741. BOOL bIsBitmap = FALSE;
  743. BOOL bUnderline;
  744. BOOL bItalic;
  745. int rmcode = 0;
  746.         CBitmap bitmap;
  748. if (!m_szWork.IsEmpty()) {
  749. char c = m_szWork[m_szWork.GetLength()-1];
  750. if(c == m_Escapes[TOP_LEVEL_GROUP]) {
  751. rmcode = 1;
  752. bItalic = FALSE;
  753. bUnderline = FALSE;
  754. m_nCurrentFontHeight = m_TextHeights[TOP_LEVEL_GROUP_HEIGHT];
  755.     bSuccess = m_fntArial.CreateFont(m_TextHeights[TOP_LEVEL_GROUP_HEIGHT], 0, 0, 0, 
  756.     FW_BOLD, bItalic, bUnderline, 0, 
  757.     ANSI_CHARSET,
  758.                     OUT_DEFAULT_PRECIS,
  759.                     CLIP_DEFAULT_PRECIS,
  760.                     PROOF_QUALITY,
  761.                     VARIABLE_PITCH | 0x04 | FF_DONTCARE,
  762.                     (LPSTR)"Arial");
  763. memDC.SetTextColor(m_Colors[TOP_LEVEL_GROUP_COLOR]);
  764. pOldFont = memDC.SelectObject(&m_fntArial);
  766. }
  767. else if(c == m_Escapes[GROUP_TITLE]) {
  768. rmcode = 1;
  769. bItalic = FALSE;
  770. bUnderline = FALSE;
  771. m_nCurrentFontHeight = m_TextHeights[GROUP_TITLE_HEIGHT];
  772.     bSuccess = m_fntArial.CreateFont(m_TextHeights[GROUP_TITLE_HEIGHT], 0, 0, 0, 
  773.     FW_BOLD, bItalic, bUnderline, 0, 
  774.     ANSI_CHARSET,
  775.                     OUT_DEFAULT_PRECIS,
  776.                     CLIP_DEFAULT_PRECIS,
  777.                     PROOF_QUALITY,
  778.                     VARIABLE_PITCH | 0x04 | FF_DONTCARE,
  779.                     (LPSTR)"Arial");
  780. memDC.SetTextColor(m_Colors[GROUP_TITLE_COLOR]);
  781. pOldFont = memDC.SelectObject(&m_fntArial);
  782. }
  783. else if(c == m_Escapes[TOP_LEVEL_TITLE]) {
  784. rmcode = 1;
  785. bItalic = FALSE;
  786. // bUnderline = TRUE;
  787. bUnderline = FALSE;
  788. m_nCurrentFontHeight = m_TextHeights[TOP_LEVEL_TITLE_HEIGHT];
  789. bSuccess = m_fntArial.CreateFont(m_TextHeights[TOP_LEVEL_TITLE_HEIGHT], 0, 0, 0, 
  790. FW_BOLD, bItalic, bUnderline, 0, 
  791. ANSI_CHARSET,
  792.                 OUT_DEFAULT_PRECIS,
  793.                 CLIP_DEFAULT_PRECIS,
  794.                 PROOF_QUALITY,
  795.                 VARIABLE_PITCH | 0x04 | FF_DONTCARE,
  796.                 (LPSTR)"Arial");
  797. memDC.SetTextColor(m_Colors[TOP_LEVEL_TITLE_COLOR]);
  798. pOldFont = memDC.SelectObject(&m_fntArial);
  799. }
  800. else if(c == m_Escapes[DISPLAY_BITMAP]) {
  801. CString szBitmap = m_szWork.Left(m_szWork.GetLength()-1);
  802. if(bitmap.LoadBitmap((const char *)szBitmap)) {
  803. BITMAP  m_bmpInfo;
  805.     bitmap.GetObject(sizeof(BITMAP), &m_bmpInfo);
  807. m_size.cx = m_bmpInfo.bmWidth; // width  of dest rect
  808. m_size.cy = m_bmpInfo.bmHeight;
  809. // upper left point of dest
  810. m_pt.x = (m_ScrollRect.right - 
  811. ((m_ScrollRect.Width())/2) - (m_size.cx/2));
  812. m_pt.y = height;
  813. pOldMemDC2Bitmap = memDC2.SelectObject(&bitmap);
  814. bIsBitmap = TRUE;
  815. }
  816. else
  817. c = ' ';
  818. }
  819. else {
  820. bItalic = FALSE;
  821. bUnderline = FALSE;
  822. m_nCurrentFontHeight = m_TextHeights[NORMAL_TEXT_HEIGHT];
  823.     bSuccess = m_fntArial.CreateFont(m_TextHeights[NORMAL_TEXT_HEIGHT], 0, 0, 0, 
  824.     FW_THIN, bItalic, bUnderline, 0, 
  825.     ANSI_CHARSET,
  826.                     OUT_DEFAULT_PRECIS,
  827.                     CLIP_DEFAULT_PRECIS,
  828.                     PROOF_QUALITY,
  829.                     VARIABLE_PITCH | 0x04 | FF_DONTCARE,
  830.                     (LPSTR)"Arial");
  831. memDC.SetTextColor(m_Colors[NORMAL_TEXT_COLOR]);
  832. pOldFont = memDC.SelectObject(&m_fntArial);
  833. }
  834. }
  836. memDC.SetBkMode(TRANSPARENT);
  838. if (!bIsBitmap)
  839. {
  840. CRect r(m_ScrollRect);
  841. r.top = height;
  842. CSize size;
  843. if(m_szWork.GetLength()-rmcode != 0) 
  844. {
  845. int x = memDC.DrawText((const char *)m_szWork,m_szWork.GetLength()-rmcode,&r,DT_TOP|DT_CENTER|
  846. DT_NOPREFIX | DT_SINGLELINE);
  847. size = memDC.GetTextExtent((LPCTSTR)m_szWork,m_szWork.GetLength()-rmcode);
  848. }
  849. else
  850. size = memDC.GetTextExtent((LPCTSTR)"W",1);
  851. height += size.cy;
  852. }
  853. else
  854. {
  855. CRect r( m_pt.x, m_pt.y, m_pt.x + m_size.cx, m_pt.y + m_size.cy);
  856. DrawBitmap(&memDC, &memDC2, &r);
  857. //     memDC.BitBlt( m_pt.x, m_pt.y, m_size.cx, m_size.cy, &memDC2, 0, 0, SRCCOPY );
  858. height += m_size.cy;
  859. }
  860. if (pOldMemDC2Bitmap != NULL) memDC2.SelectObject(pOldMemDC2Bitmap);
  861. if (pOldFont != NULL) memDC.SelectObject(pOldFont);
  862. }
  863. memDC.SelectObject(pOldMemDCBitmap);
  864. }
  866. void CCreditStatic::OnDestroy() 
  867. {
  868. CStatic::OnDestroy();
  870. m_ArrCredit.RemoveAll();
  872. if(TimerOn)
  873. ASSERT(KillTimer(DISPLAY_TIMER_ID));
  874. }
  876. BOOL CCreditStatic::SetBkImage(UINT nIDResource)
  877. {
  878.     return SetBkImage( (LPCTSTR)nIDResource );
  879. }
  881. BOOL CCreditStatic::SetBkImage(LPCTSTR lpszResourceName)
  882. {
  884.     // If this is not the first call then Delete GDI objects
  885.     if( m_bitmap.m_hObject != NULL )
  886. m_bitmap.DeleteObject();
  887.     if( m_pal.m_hObject != NULL )
  888. m_pal.DeleteObject();
  889.     
  890.     
  891.     HBITMAP hBmp = (HBITMAP)::LoadImage( AfxGetInstanceHandle(), 
  892.             lpszResourceName, IMAGE_BITMAP, 0,0, LR_CREATEDIBSECTION );
  894.      if( hBmp == NULL ) 
  895.         return FALSE;
  897. m_bitmap.Attach( hBmp );
  898.     BITMAP bm;
  899.     m_bitmap.GetBitmap( &bm );
  900.     m_cxBitmap = bm.bmWidth;
  901.     m_cyBitmap = bm.bmHeight;
  903.     // Create a logical palette for the bitmap
  904.     DIBSECTION ds;
  905.     BITMAPINFOHEADER &bmInfo = ds.dsBmih;
  906.     m_bitmap.GetObject( sizeof(ds), &ds );
  908.     int nColors = bmInfo.biClrUsed ? bmInfo.biClrUsed : 1 << bmInfo.biBitCount;
  910.     // Create a halftone palette if colors > 256. 
  911.     CClientDC dc(NULL);             // Desktop DC
  912.     if( nColors > 256 )
  913.         m_pal.CreateHalftonePalette( &dc );
  914.     else
  915.     {
  916.         // Create the palette
  918.         RGBQUAD *pRGB = new RGBQUAD[nColors];
  919.         CDC memDC;
  920.         memDC.CreateCompatibleDC(&dc);
  922.         CBitmap* pOldMemDCBitmap = memDC.SelectObject( &m_bitmap );
  923.         ::GetDIBColorTable( memDC, 0, nColors, pRGB );
  925.         UINT nSize = sizeof(LOGPALETTE) + (sizeof(PALETTEENTRY) * nColors);
  926.         LOGPALETTE *pLP = (LOGPALETTE *) new BYTE[nSize];
  928.         pLP->palVersion = 0x300;
  929.         pLP->palNumEntries = nColors;
  931.         for( int i=0; i < nColors; i++)
  932.         {
  933.             pLP->palPalEntry[i].peRed = pRGB[i].rgbRed;
  934.             pLP->palPalEntry[i].peGreen = pRGB[i].rgbGreen;
  935.             pLP->palPalEntry[i].peBlue = pRGB[i].rgbBlue;
  936.             pLP->palPalEntry[i].peFlags = 0;
  937.         }
  939.         m_pal.CreatePalette( pLP );
  941. memDC.SelectObject(pOldMemDCBitmap);
  942.         delete[] pLP;
  943.         delete[] pRGB;
  944.     }
  945. //    Invalidate();
  947.     return TRUE;
  948. }