QQ登录

只需一步,快速开始

上位机MFC滚动文本实例

[ 复制链接 ]
效果演示
当前程序基于CStatic派生了一个CReditStatic类,用于实现滚动文本。
通常程序都有一个关于对话框,如果将对话框内容设计成滚动效果,
美化程序的同时,也可以将过多的内容以滚动形式展示给用户阅读。
下面是程序效果图:

上位机MFC滚动文本实例

上位机MFC滚动文本实例


实现过程:
1.同样也是建立一个测试工程,这里是对话框工程。
在对话框上添加一静态文本控件,ID设置为IDC_STATIC1,用于显示滚动文本内容。

2.将例程根目录两文件CREDITSTATIC.CPP,CREDITSTATIC.H复制到自己工程。
再导入到工程,这样工程会多出一集成类CCreditStatic。

3.下面就是对这个类的使用。在 主对话框类中包含类头文件,添加类实例,并初始化
#include "CreditStatic.h"
private:
        CCreditStatic m_static;
        UINT m_bitmapIDs[2];


        m_bitmapIDs[0] = IDB_BITMAP1;
        m_bitmapIDs[1] = IDB_BITMAP2;
        m_static.SubclassDlgItem(IDC_STATIC1,this);
        m_static.SetCredits(pText);
        m_static.SetSpeed(DISPLAY_FAST);
        m_static.SetColor(BACKGROUND_COLOR, RGB(0,0,255));
        m_static.SetTransparent();
        m_static.SetGradient(GRADIENT_RIGHT_DARK);
        m_static.SetBkImage(IDB_BITMAP1);
        m_static.StartScrolling();
        SetTimer(1,5000,NULL);


这里添加了一个定时器,用于间隔显示静态文本控件的不同背景
void CCTestDlg::OnTimer(UINT nIDEvent)
{
        static int index = 0;
        index = ++index % 2;
        m_static.SetBkImage(m_bitmapIDs[index]);
       
        CDialog::OnTimer(nIDEvent);
}


其中pText为要显示的文本内容,如例程的:
  1. char *pText = { "|NETBAS FOR WINDOWS NT\t||Copyright (c) 1998|"
  2.         "Test Data AS|All Rights Reserved||"
  3.         "BITMAP1^||"    // this is a quoted bitmap resource
  4.         "Project Lead\r||Kjetil Kvamme|||"
  5.         "Technical Lead\r||Paul K. Tonder|||"
  6.         "Engineering Lead\r||Paul K. Tonder|||"
  7.         "Product Lead\r||Tom Rotting|||"
  8.         "Engineering\r||Paul K. Tonder,  Rolf T. Wold,  Sigbjorn Helset|"
  9.         "Reidar Ognedal,  Kjetil Kvamme, Arne Bakken|||"
  10.         "BITMAP2^|||"  // this is a quoted bitmap resource
  11.         "QA\r||Mary Hech,  Sam Bamnm,  Ron Fonn,  Steve Waeve|"
  12.         "Igor Borisnoff,  FellaB |||"
  13.         "Documentation\r||"
  14.         "Arvid Molnvik,  Joanne Hone,  Annette Fune|||"
  15.         "Technical Program Office\r||Burf Murphy, Foll Roller||||"
  16.         "Systems Support\r||Bendy Land|||"
  17.         "Administrative Support\r||Donna Fonna|||"
  18.         "* * * * * * * * *\t|||"
  19.         "BITMAP3^||"
  20.         "Project Manager\r||Dwain Kinghorn|||"
  21.         "Engineering\r||"
  22.         "Hank Bank,  Ray Fay,  Bill Sill,  Mark Dark,  Peter Leter|"
  23.         "Lev Bef|||Quality Assurance\r||"
  24.         "Biff Bin||||"
  25.         "BITMAP4^|||||"
  26.         };
复制代码
例程中使用的位图资源如IDB_BITMAP1,可以自己添加,也可使用例程的,注意资源ID保持一致便可。

4.最后就是编译运行例程,查看效果
下面是文件源代码,可以复制使用,也可以下载例程工程使用:
请点击此处下载

请先注册会员后在进行下载

已注册会员,请先登录后下载

文件名称:CTest.rar 
文件大小:129.33 KB  售价:10金币
下载权限: 不限 以上或 VIP会员   [购买捐助会员]   [充值积分]   有问题联系我


  1. #if !defined(AFX_CREDITSTATIC_H__4ABD7701_49F5_11D1_9E3C_00A0245800CF__INCLUDED_)
  2. #define AFX_CREDITSTATIC_H__4ABD7701_49F5_11D1_9E3C_00A0245800CF__INCLUDED_

  3. #if _MSC_VER >= 1000
  4. #pragma once
  5. #endif // _MSC_VER >= 1000
  6. // CreditStatic.h : header file
  7. //

  8. #define DISPLAY_SLOW                0
  9. #define DISPLAY_MEDIUM                1
  10. #define DISPLAY_FAST                2

  11. #define BACKGROUND_COLOR        0
  12. #define TOP_LEVEL_TITLE_COLOR        1
  13. #define TOP_LEVEL_GROUP_COLOR   2
  14. #define GROUP_TITLE_COLOR       3
  15. #define NORMAL_TEXT_COLOR                4

  16. #define TOP_LEVEL_TITLE_HEIGHT        0               
  17. #define TOP_LEVEL_GROUP_HEIGHT  1     
  18. #define GROUP_TITLE_HEIGHT            2     
  19. #define        NORMAL_TEXT_HEIGHT                3

  20. #define TOP_LEVEL_TITLE                        0   // '\t'
  21. #define TOP_LEVEL_GROUP         1   // '\n'
  22. #define GROUP_TITLE                   2   // '\r'
  23. #define DISPLAY_BITMAP                        3   // '^'

  24. #define GRADIENT_NONE                        0
  25. #define GRADIENT_RIGHT_DARK                1
  26. #define GRADIENT_RIGHT_LIGHT        2
  27. #define GRADIENT_LEFT_DARK                3
  28. #define GRADIENT_LEFT_LIGHT                4

  29. class CCreditStatic : public CStatic
  30. {
  31. protected:
  32.         COLORREF    m_Colors[5];
  33.         int         m_TextHeights[4];
  34.             TCHAR       m_Escapes[4];
  35.         int         m_DisplaySpeed[3],m_CurrentSpeed;
  36. //         CRect       m_ScrollRect;                   // rect of Static Text frame
  37.         CStringList m_ArrCredit;
  38.         CString                m_szWork;
  39.         int         m_nCounter;                   // work ints
  40.         POSITION    m_ArrIndex;
  41.         BOOL        m_bFirstTime;
  42.         BOOL        m_bDrawText;
  43.         int         m_nClip,m_ScrollAmount;
  44.         int         m_nCurrentFontHeight;

  45.         CBitmap     m_bmpWork;                  // bitmap holder
  46.         CBitmap                m_BmpMain;                  // bitmap holder

  47.         CSize                 m_size;                     // drawing helpers
  48.         CPoint                 m_pt;
  49.         BOOL                 m_bProcessingBitmap;
  50.         CPalette        m_pal;
  51.         CBitmap                m_bitmap;
  52.         int m_cxBitmap, m_cyBitmap;
  53.         BOOL                m_bFirstTurn;
  54.         UINT        m_Gradient;
  55.         BOOL                m_bTransparent;
  56.         int                        n_MaxWidth;
  57.         UINT        TimerOn;
  58. // Construction
  59. public:
  60.         CCreditStatic();

  61. // Attributes
  62. public:

  63. // Operations
  64. public:
  65.         BOOL StartScrolling();
  66.         void EndScrolling();
  67.         void SetCredits(LPCTSTR credits, char delimiter = '|');
  68.         void SetCredits(UINT nID, char delimiter = '|');
  69.         void SetSpeed(UINT index, int speed = 0);
  70.         void SetColor(UINT index, COLORREF col);
  71.         void SetTextHeight(UINT index, int height);
  72.         void SetEscape(UINT index, char escape);
  73.         void SetGradient(UINT value = GRADIENT_RIGHT_DARK);
  74.         BOOL SetBkImage(UINT nIDResource);
  75.         BOOL SetBkImage(LPCTSTR lpszResourceName);
  76.         void SetTransparent(BOOL bTransparent = TRUE);
  77. // Overrides
  78.         // ClassWizard generated virtual function overrides
  79.         //{{AFX_VIRTUAL(CCreditStatic)
  80.         //}}AFX_VIRTUAL

  81. // Implementation
  82. public:
  83.         virtual ~CCreditStatic();

  84.         // Generated message map functions
  85. protected:
  86.         void MoveCredit(CDC *pDC, CRect& r, CRect& r2, BOOL bCheck);
  87.         void AddBackGround(CDC* pDC, CRect& m_ScrollRect, CRect& m_ClientRect);
  88.         void DrawCredit(CDC* pDC, CRect& m_ScrollRect);
  89.         void FillGradient(CDC *pDC, CRect *m_ScrollRect, CRect *m_FillRect, COLORREF color);
  90.         void DrawBitmap(CDC* pDC, CDC* pDC2, CRect *rBitmap);

  91.         //{{AFX_MSG(CCreditStatic)
  92.         afx_msg void OnPaint();
  93.         afx_msg BOOL OnEraseBkgnd(CDC* pDC);
  94.         afx_msg void OnTimer(UINT nIDEvent);
  95.         afx_msg void OnDestroy();
  96.         //}}AFX_MSG

  97.         DECLARE_MESSAGE_MAP()
  98. };

  99. /////////////////////////////////////////////////////////////////////////////

  100. //{{AFX_INSERT_LOCATION}}
  101. // Microsoft Developer Studio will insert additional declarations immediately before the previous line.

  102. #endif // !defined(AFX_CREDITSTATIC_H__4ABD7701_49F5_11D1_9E3C_00A0245800CF__INCLUDED_)
复制代码
  1. #include "stdafx.h"
  2. #include "CreditStatic.h"

  3. #ifdef _DEBUG
  4. #define new DEBUG_NEW
  5. #undef THIS_FILE
  6. static char THIS_FILE[] = __FILE__;
  7. #endif

  8. #define  DISPLAY_TIMER_ID                150                // timer id
  9. /////////////////////////////////////////////////////////////////////////////
  10. // CCreditStatic

  11. CCreditStatic::CCreditStatic()
  12. {

  13.         m_Colors[0] = RGB(0,0,0);       // Black
  14.         m_Colors[1] = RGB(255,0,0);     // Red
  15.         m_Colors[2] = RGB(255,255,0);   // Yellow
  16.         m_Colors[3] = RGB(0,255,255);   // Turquoise
  17.         m_Colors[4] = RGB(255,255,255); // White

  18.         m_TextHeights[0] = 21;
  19.         m_TextHeights[1] = 19;
  20.         m_TextHeights[2] = 17;
  21.         m_TextHeights[3] = 15;
  22.         m_nCurrentFontHeight = m_TextHeights[NORMAL_TEXT_HEIGHT];


  23.         m_Escapes[0] = '\t';
  24.         m_Escapes[1] = '\n';
  25.         m_Escapes[2] = '\r';
  26.         m_Escapes[3] = '^';

  27.         m_DisplaySpeed[0] = 70;
  28.         m_DisplaySpeed[1] = 40;
  29.         m_DisplaySpeed[2] = 10;

  30.         m_CurrentSpeed = 1;
  31.         m_ScrollAmount = -1;
  32.         m_bProcessingBitmap = FALSE;

  33.         m_ArrIndex = NULL;
  34.         m_nCounter = 1;
  35.         m_nClip = 0;

  36.         m_bFirstTime = TRUE;
  37.         m_bDrawText = FALSE;
  38.         m_bFirstTurn = TRUE;
  39.         m_Gradient = GRADIENT_NONE;
  40.         m_bTransparent = FALSE;
  41.         n_MaxWidth = 0;
  42.         TimerOn = 0;
  43. }

  44. CCreditStatic::~CCreditStatic()
  45. {
  46. }


  47. BEGIN_MESSAGE_MAP(CCreditStatic, CStatic)
  48.         //{{AFX_MSG_MAP(CCreditStatic)
  49.         ON_WM_PAINT()
  50.         ON_WM_ERASEBKGND()
  51.         ON_WM_TIMER()
  52.         ON_WM_DESTROY()
  53.         //}}AFX_MSG_MAP
  54. END_MESSAGE_MAP()

  55. /////////////////////////////////////////////////////////////////////////////
  56. // CCreditStatic message handlers

  57. BOOL CCreditStatic::StartScrolling()
  58. {
  59.         if(m_ArrCredit.IsEmpty())
  60.                 return FALSE;

  61.         if(m_BmpMain.m_hObject != NULL) {
  62.                 m_BmpMain.DeleteObject();
  63.                 m_BmpMain.m_hObject = NULL;
  64.         }
  65.        
  66.         TimerOn = SetTimer(DISPLAY_TIMER_ID,m_DisplaySpeed[m_CurrentSpeed],NULL);
  67.     ASSERT(TimerOn != 0);

  68.         m_ArrIndex = m_ArrCredit.GetHeadPosition();
  69.         m_nCounter = 1;
  70.         m_nClip = 0;

  71.         m_bFirstTime = TRUE;
  72.         m_bDrawText = FALSE;

  73.         return TRUE;
  74. }

  75. void CCreditStatic::EndScrolling()
  76. {
  77.         KillTimer(DISPLAY_TIMER_ID);
  78.         TimerOn = 0;

  79.         if(m_BmpMain.m_hObject != NULL) {
  80.                 m_BmpMain.DeleteObject();
  81.                 m_BmpMain.m_hObject = NULL;
  82.         }
  83. }

  84. void CCreditStatic::SetCredits(LPCTSTR credits,char delimiter)
  85. {
  86.         char *str,*ptr1,*ptr2;
  87.    
  88.         ASSERT(credits);

  89.         if((str = strdup(credits)) == NULL)
  90.                 return;

  91.         m_ArrCredit.RemoveAll();

  92.         ptr1 = str;
  93.         while((ptr2 = strchr(ptr1,delimiter)) != NULL) {
  94.                 *ptr2 = '\0';
  95.                 m_ArrCredit.AddTail(ptr1);
  96.                 ptr1 = ptr2+1;
  97.         }
  98.         m_ArrCredit.AddTail(ptr1);

  99.         free(str);

  100.         m_ArrIndex = m_ArrCredit.GetHeadPosition();
  101.         m_nCounter = 1;
  102.         m_nClip = 0;

  103.         m_bFirstTime = TRUE;
  104.         m_bDrawText = FALSE;
  105. }

  106. void CCreditStatic::SetCredits(UINT nID,char delimiter)
  107. {
  108.         CString credits;
  109.         if(!credits.LoadString(nID))
  110.                 return;

  111.         SetCredits((LPCTSTR)credits, delimiter);
  112. }

  113. void CCreditStatic::SetSpeed(UINT index, int speed)
  114. {
  115.         ASSERT(index <= DISPLAY_FAST);

  116.         if(speed)
  117.                 m_DisplaySpeed[index] = speed;

  118.         m_CurrentSpeed = index;
  119. }

  120. void CCreditStatic::SetColor(UINT index, COLORREF col)
  121. {
  122.         ASSERT(index <= NORMAL_TEXT_COLOR);

  123.         m_Colors[index] = col;
  124. }

  125. void CCreditStatic::SetTextHeight(UINT index, int height)
  126. {
  127.         ASSERT(index <= NORMAL_TEXT_HEIGHT);

  128.         m_TextHeights[index] = height;
  129. }

  130. void CCreditStatic::SetEscape(UINT index, char escape)
  131. {
  132.         ASSERT(index <= DISPLAY_BITMAP);

  133.         m_Escapes[index] = escape;
  134. }

  135. void CCreditStatic::SetGradient(UINT value)
  136. {
  137.         ASSERT(value <= GRADIENT_LEFT_LIGHT);

  138.         m_Gradient = value;
  139. }

  140. void CCreditStatic::SetTransparent(BOOL bTransparent)
  141. {
  142.         m_bTransparent = bTransparent;
  143. }

  144. void CCreditStatic::OnPaint()
  145. {
  146.         CPaintDC dc(this); // device context for painting
  147.        
  148.         if(TimerOn) return;

  149.         CDC memDC;
  150.         memDC.CreateCompatibleDC(&dc);

  151.         CBitmap *pOldMemDCBitmap = NULL;
  152.         CRect m_ScrollRect;
  153.         GetClientRect(&m_ScrollRect);

  154.         if(m_BmpMain.m_hObject == NULL) {

  155.                 CDC memDC2;
  156.                 CBitmap bitmap;
  157.                 memDC2.CreateCompatibleDC(&dc);
  158.                 bitmap.CreateCompatibleBitmap( &dc, m_ScrollRect.Width(), m_ScrollRect.Height() );
  159.                 CBitmap *pOldMemDC2Bitmap = (CBitmap*)memDC2.SelectObject(&bitmap);
  160.                
  161.                 DrawCredit(&memDC2, m_ScrollRect);
  162.                 AddBackGround(&memDC2, m_ScrollRect, m_ScrollRect);

  163.                 pOldMemDCBitmap = (CBitmap*)memDC.SelectObject(&m_BmpMain);
  164.         memDC.BitBlt( 0, 0, m_ScrollRect.Width(), m_ScrollRect.Height(),
  165.                                         &memDC2, 0, 0, SRCCOPY );
  166.                 memDC2.SelectObject(pOldMemDC2Bitmap);
  167.         }
  168.         else
  169.                 pOldMemDCBitmap = (CBitmap*)memDC.SelectObject(&m_BmpMain);
  170.       
  171.         dc.BitBlt( 0, 0, m_ScrollRect.Width(), m_ScrollRect.Height(),
  172.                &memDC, 0, 0, SRCCOPY );
  173. }

  174. BOOL CCreditStatic::OnEraseBkgnd(CDC* pDC)
  175. {
  176.         return TRUE;
  177.        
  178. //        return CStatic::OnEraseBkgnd(pDC);
  179. }

  180. //************************************************************************
  181. //         OnTimer
  182. //
  183. //                 On each of the display timers, scroll the window 1 unit. Each 20
  184. //      units, fetch the next array element and load into work string. Call
  185. //      Invalidate and UpdateWindow to invoke the OnPaint which will paint
  186. //      the contents of the newly updated work string.
  187. //************************************************************************
  188. void CCreditStatic::OnTimer(UINT nIDEvent)
  189. {
  190.         if (nIDEvent != DISPLAY_TIMER_ID)
  191.         {
  192.                 CStatic::OnTimer(nIDEvent);
  193.                 return;
  194.         }

  195.         BOOL bCheck = FALSE;

  196.         if (!m_bProcessingBitmap) {
  197.                 if (m_nCounter++ % m_nCurrentFontHeight == 0)         // every x timer events, show new line
  198.                 {
  199.                         m_nCounter=1;
  200.                         m_szWork = m_ArrCredit.GetNext(m_ArrIndex);
  201.                         if(m_bFirstTurn)
  202.                                 bCheck = TRUE;
  203.                         if(m_ArrIndex == NULL) {
  204.                                 m_bFirstTurn = FALSE;
  205.                                 m_ArrIndex = m_ArrCredit.GetHeadPosition();
  206.                         }
  207.                         m_nClip = 0;
  208.                         m_bDrawText=TRUE;
  209.                 }
  210.         }
  211.        
  212.     CClientDC dc(this);
  213.         CRect m_ScrollRect;
  214.         GetClientRect(&m_ScrollRect);

  215.         CRect m_ClientRect(m_ScrollRect);
  216.         m_ClientRect.left = (m_ClientRect.Width()-n_MaxWidth)/2;
  217.         m_ClientRect.right = m_ClientRect.left + n_MaxWidth;

  218.         MoveCredit(&dc, m_ScrollRect, m_ClientRect, bCheck);

  219.         AddBackGround(&dc, m_ScrollRect, m_ClientRect);

  220.         CStatic::OnTimer(nIDEvent);
  221. }

  222. void CCreditStatic::AddBackGround(CDC* pDC, CRect& m_ScrollRect, CRect& m_ClientRect)
  223. {
  224.         CDC memDC;
  225.         memDC.CreateCompatibleDC( pDC );

  226.     if( m_bitmap.m_hObject == NULL )
  227.         {
  228.         CBitmap* pOldBitmap = memDC.SelectObject( &m_BmpMain );
  229.         pDC->BitBlt( 0, 0, m_ScrollRect.Width(), m_ScrollRect.Height(),
  230.                                         &memDC, 0, 0, SRCCOPY );
  231.                 memDC.SelectObject(pOldBitmap);
  232.                 return;
  233.         }

  234.    // Draw bitmap in the background if one has been set
  235.                 // Now create a mask
  236.         CBitmap bitmap;
  237.         bitmap.CreateCompatibleBitmap( pDC, m_ClientRect.Width(), m_ClientRect.Height() );
  238.         CBitmap* pOldMemDCBitmap = memDC.SelectObject( &bitmap );
  239.                
  240.         CDC tempDC;
  241.         tempDC.CreateCompatibleDC(pDC);
  242.         CBitmap* pOldTempDCBitmap = tempDC.SelectObject( &m_BmpMain );

  243.         memDC.BitBlt( 0, 0, m_ClientRect.Width(), m_ClientRect.Height(), &tempDC,
  244.                       m_ClientRect.left, m_ClientRect.top, SRCCOPY );
  245.         CDC maskDC;
  246.         maskDC.CreateCompatibleDC(pDC);
  247.         CBitmap maskBitmap;

  248.         // Create monochrome bitmap for the mask
  249.         maskBitmap.CreateBitmap( m_ClientRect.Width(), m_ClientRect.Height(), 1, 1, NULL );
  250.         CBitmap* pOldMaskDCBitmap = maskDC.SelectObject( &maskBitmap );
  251.     memDC.SetBkColor(m_bTransparent? RGB(192,192,192): m_Colors[BACKGROUND_COLOR]);

  252.         // Create the mask from the memory DC
  253.         maskDC.BitBlt( 0, 0, m_ClientRect.Width(), m_ClientRect.Height(), &memDC, 0, 0, SRCCOPY );

  254.         tempDC.SelectObject(pOldTempDCBitmap);
  255.         pOldTempDCBitmap = tempDC.SelectObject( &m_bitmap );

  256.         CDC imageDC;
  257.         CBitmap bmpImage;
  258.         imageDC.CreateCompatibleDC( pDC );
  259.         bmpImage.CreateCompatibleBitmap( pDC, m_ScrollRect.Width(), m_ScrollRect.Height() );
  260.         CBitmap* pOldImageDCBitmap = imageDC.SelectObject( &bmpImage );

  261.         if( pDC->GetDeviceCaps(RASTERCAPS) & RC_PALETTE && m_pal.m_hObject != NULL )
  262.         {
  263.                 pDC->SelectPalette( &m_pal, FALSE );
  264.                 pDC->RealizePalette();

  265.                 imageDC.SelectPalette( &m_pal, FALSE );
  266.         }
  267.         // Get x and y offset
  268.         // Draw bitmap in tiled manner to imageDC
  269.         for( int i = 0; i < m_ScrollRect.right; i += m_cxBitmap )
  270.                 for( int j = 0; j < m_ScrollRect.bottom; j += m_cyBitmap )
  271.                         imageDC.BitBlt( i, j, m_cxBitmap, m_cyBitmap, &tempDC, 0, 0, SRCCOPY );

  272.         // Set the background in memDC to black. Using SRCPAINT with black and any other
  273.         // color results in the other color, thus making black the transparent color
  274.         memDC.SetBkColor(RGB(0,0,0));
  275.         memDC.SetTextColor(RGB(255,255,255));
  276.         memDC.BitBlt(0, 0, m_ClientRect.Width(), m_ClientRect.Height(), &maskDC, 0, 0, SRCAND);

  277.         // Set the foreground to black. See comment above.
  278.         imageDC.SetBkColor(RGB(255,255,255));
  279.         imageDC.SetTextColor(RGB(0,0,0));
  280.         imageDC.BitBlt(m_ClientRect.left, m_ClientRect.top, m_ClientRect.Width(), m_ClientRect.Height(),
  281.                                         &maskDC, 0, 0, SRCAND);

  282.         // Combine the foreground with the background
  283.     imageDC.BitBlt(m_ClientRect.left, m_ClientRect.top, m_ClientRect.Width(), m_ClientRect.Height(),
  284.                                         &memDC, 0, 0,SRCPAINT);

  285.         // Draw the final image to the screen   
  286.         pDC->BitBlt( 0, 0, m_ScrollRect.Width(), m_ScrollRect.Height(),
  287.                                         &imageDC, 0, 0, SRCCOPY );

  288.         imageDC.SelectObject(pOldImageDCBitmap);
  289.         maskDC.SelectObject(pOldMaskDCBitmap);
  290.         tempDC.SelectObject(pOldTempDCBitmap);
  291.         memDC.SelectObject(pOldMemDCBitmap);
  292. }

  293. void CCreditStatic::DrawBitmap(CDC* pDC, CDC* pDC2, CRect *rBitmap)
  294. {
  295.         if(!m_bTransparent || m_bitmap.m_hObject != NULL) {
  296.             pDC->BitBlt( rBitmap->left, rBitmap->top, rBitmap->Width(), rBitmap->Height(),
  297.                                    pDC2, 0, 0, SRCCOPY );
  298.                 return;
  299.         }

  300.         CDC memDC;
  301.         memDC.CreateCompatibleDC( pDC );

  302.     // Now create a mask
  303.         CBitmap bitmap;
  304.         bitmap.CreateCompatibleBitmap( pDC, rBitmap->Width(), rBitmap->Height() );
  305.         CBitmap* pOldMemDCBitmap = memDC.SelectObject( &bitmap );
  306.                
  307.         memDC.BitBlt( 0, 0, rBitmap->Width(), rBitmap->Height(), pDC2, 0, 0, SRCCOPY );

  308.         CDC maskDC;
  309.         maskDC.CreateCompatibleDC(pDC);

  310.         // Create monochrome bitmap for the mask
  311.         CBitmap maskBitmap;
  312.         maskBitmap.CreateBitmap( rBitmap->Width(), rBitmap->Height(), 1, 1, NULL );
  313.         CBitmap* pOldMaskDCBitmap = maskDC.SelectObject( &maskBitmap );
  314.     memDC.SetBkColor(RGB(192,192,192));

  315.         // Create the mask from the memory DC
  316.         maskDC.BitBlt( 0, 0, rBitmap->Width(), rBitmap->Height(), &memDC, 0, 0, SRCCOPY );


  317.         CDC imageDC;
  318.         CBitmap bmpImage;
  319.         imageDC.CreateCompatibleDC( pDC );
  320.         bmpImage.CreateCompatibleBitmap( pDC, rBitmap->Width(), rBitmap->Height() );
  321.         CBitmap* pOldImageDCBitmap = imageDC.SelectObject( &bmpImage );

  322.         imageDC.BitBlt(0, 0, rBitmap->Width(), rBitmap->Height(), pDC, rBitmap->left, rBitmap->top, SRCCOPY);

  323.         // Set the background in memDC to black. Using SRCPAINT with black and any other
  324.         // color results in the other color, thus making black the transparent color
  325.         memDC.SetBkColor(RGB(0,0,0));
  326.         memDC.SetTextColor(RGB(255,255,255));
  327.         memDC.BitBlt(0, 0, rBitmap->Width(), rBitmap->Height(), &maskDC, 0, 0, SRCAND);

  328.         // Set the foreground to black. See comment above.
  329.         imageDC.SetBkColor(RGB(255,255,255));
  330.         imageDC.SetTextColor(RGB(0,0,0));
  331.         imageDC.BitBlt(0, 0, rBitmap->Width(), rBitmap->Height(), &maskDC, 0, 0, SRCAND);

  332.         // Combine the foreground with the background
  333.     imageDC.BitBlt(0, 0, rBitmap->Width(), rBitmap->Height(), &memDC, 0, 0,SRCPAINT);

  334.         // Draw the final image to the screen   
  335.         pDC->BitBlt( rBitmap->left, rBitmap->top, rBitmap->Width(), rBitmap->Height(),
  336.                                         &imageDC, 0, 0, SRCCOPY );

  337.         imageDC.SelectObject(pOldImageDCBitmap);
  338.         maskDC.SelectObject(pOldMaskDCBitmap);
  339.         memDC.SelectObject(pOldMemDCBitmap);
  340. }

  341. void CCreditStatic::FillGradient(CDC *pDC, CRect *m_ScrollRect, CRect *m_FillRect, COLORREF color)
  342. {
  343.         float fStep,fRStep,fGStep,fBStep;            // How large is each band?
  344.         int iOnBand;  // Loop index

  345.         WORD R = GetRValue(color);
  346.         WORD G = GetGValue(color);
  347.         WORD B = GetBValue(color);

  348.         // Determine how large each band should be in order to cover the
  349.         // client with 256 bands (one for every color intensity level)
  350.         if(m_Gradient % 2) {
  351.                 fRStep = (float)R / 255.0f;
  352.                 fGStep = (float)G / 255.0f;
  353.                 fBStep = (float)B / 255.0f;
  354.         } else {
  355.                 fRStep = (float)(255-R) / 255.0f;
  356.                 fGStep = (float)(255-G) / 255.0f;
  357.                 fBStep = (float)(255-B) / 255.0f;
  358.         }

  359.         COLORREF OldCol = pDC->GetBkColor();
  360.         // Start filling bands
  361.         fStep = (float)m_ScrollRect->Width() / 256.0f;
  362.         for(iOnBand = (256*m_FillRect->left)/m_ScrollRect->Width();
  363.                 (int)(iOnBand*fStep) < m_FillRect->right && iOnBand < 256; iOnBand++) {
  364.                 CRect r((int)(iOnBand * fStep), m_FillRect->top,
  365.                                 (int)((iOnBand+1) * fStep), m_FillRect->bottom+1);
  366.                 COLORREF col;

  367.                 switch(m_Gradient) {
  368.                 case GRADIENT_RIGHT_DARK:
  369.                         col = RGB((int)(R-iOnBand*fRStep),(int)(G-iOnBand*fGStep),(int)(B-iOnBand*fBStep));
  370.                         break;
  371.                 case GRADIENT_RIGHT_LIGHT:
  372.                         col = RGB((int)(R+iOnBand*fRStep),(int)(G+iOnBand*fGStep),(int)(B+iOnBand*fBStep));
  373.                         break;
  374.                 case GRADIENT_LEFT_DARK:
  375.                         col = RGB((int)(iOnBand*fRStep),(int)(iOnBand*fGStep),(int)(iOnBand*fBStep));
  376.                         break;
  377.                 case GRADIENT_LEFT_LIGHT:
  378.                         col = RGB(255-(int)(iOnBand*fRStep),255-(int)(iOnBand*fGStep),255-(int)(iOnBand*fBStep));
  379.                         break;
  380.                 default:
  381.                         return;
  382.                 }
  383.                 pDC->FillSolidRect(&r, col);
  384.         }
  385.         pDC->SetBkColor(OldCol);
  386. }

  387. #define SCROLLDC

  388. void CCreditStatic::MoveCredit(CDC* pDC, CRect& m_ScrollRect, CRect& m_ClientRect, BOOL bCheck)
  389. {
  390.         CDC memDC,memDC2;
  391.     memDC.CreateCompatibleDC(pDC);
  392.     memDC2.CreateCompatibleDC(pDC);
  393.    
  394.         COLORREF BackColor = (m_bTransparent && m_bitmap.m_hObject != NULL)? RGB(192,192,192) : m_Colors[BACKGROUND_COLOR];
  395.         CBitmap *pOldMemDCBitmap = NULL;
  396.         CBitmap        *pOldMemDC2Bitmap = NULL;

  397. #ifdef SCROLLDC
  398.         CRect r1;
  399. #endif

  400.         if(m_BmpMain.m_hObject == NULL) {
  401.                 m_BmpMain.CreateCompatibleBitmap( pDC, m_ScrollRect.Width(), m_ScrollRect.Height() );
  402.                 pOldMemDCBitmap = (CBitmap*)memDC.SelectObject(&m_BmpMain);
  403.                 if(m_Gradient && m_bitmap.m_hObject == NULL)
  404.                         FillGradient(&memDC, &m_ScrollRect, &m_ScrollRect,m_Colors[BACKGROUND_COLOR]);
  405.                 else
  406.                         memDC.FillSolidRect(&m_ScrollRect,BackColor);
  407.         } else
  408.                 pOldMemDCBitmap = (CBitmap*)memDC.SelectObject(&m_BmpMain);

  409.         if(m_ClientRect.Width() > 0) {
  410. #ifndef SCROLLDC
  411.                 CBitmap bitmap;
  412.                 bitmap.CreateCompatibleBitmap( pDC, m_ClientRect.Width(), m_ClientRect.Height() );
  413.                 pOldMemDC2Bitmap = memDC2.SelectObject(&bitmap);

  414.                 memDC2.BitBlt( 0, 0, m_ClientRect.Width(), m_ClientRect.Height()-abs(m_ScrollAmount),
  415.                     &memDC, m_ClientRect.left, abs(m_ScrollAmount), SRCCOPY );
  416.                 memDC.BitBlt( m_ClientRect.left, 0, m_ClientRect.Width(), m_ClientRect.Height(),
  417.                     &memDC2, 0, 0, SRCCOPY );

  418.                
  419.                 memDC2.SelectObject(pOldMemDC2Bitmap);
  420.                 pOldMemDC2Bitmap = NULL;
  421. #else
  422.                 CRgn RgnUpdate;
  423.                 memDC.ScrollDC(0,m_ScrollAmount,(LPCRECT)m_ScrollRect,(LPCRECT)m_ClientRect,&RgnUpdate,
  424.                                                 (LPRECT)r1);
  425.     }
  426.         else {
  427.                 r1 = m_ScrollRect;
  428.                 r1.top = r1.bottom-abs(m_ScrollAmount);
  429. #endif
  430.         }

  431.         m_nClip = m_nClip + abs(m_ScrollAmount);       
  432.        

  433.         //*********************************************************************
  434.         //        FONT SELECTION
  435.     CFont m_fntArial;
  436.         CFont* pOldFont = NULL;
  437.         BOOL bSuccess = FALSE;
  438.        
  439.         BOOL bUnderline;
  440.         BOOL bItalic;
  441.     int rmcode = 0;

  442.         if (!m_szWork.IsEmpty()) {
  443.                 char c = m_szWork[m_szWork.GetLength()-1];
  444.                 if(c == m_Escapes[TOP_LEVEL_GROUP]) {
  445.                         rmcode = 1;
  446.                         bItalic = FALSE;
  447.                         bUnderline = FALSE;
  448.                         m_nCurrentFontHeight = m_TextHeights[TOP_LEVEL_GROUP_HEIGHT];
  449.                            bSuccess = m_fntArial.CreateFont(m_TextHeights[TOP_LEVEL_GROUP_HEIGHT], 0, 0, 0,
  450.                                                                    FW_BOLD, bItalic, bUnderline, 0,
  451.                                                                    ANSI_CHARSET,
  452.                            OUT_DEFAULT_PRECIS,
  453.                            CLIP_DEFAULT_PRECIS,
  454.                            PROOF_QUALITY,
  455.                            VARIABLE_PITCH | 0x04 | FF_DONTCARE,
  456.                            (LPSTR)"Arial");
  457.                         memDC.SetTextColor(m_Colors[TOP_LEVEL_GROUP_COLOR]);
  458.                         if (pOldFont != NULL) memDC.SelectObject(pOldFont);
  459.                         pOldFont = memDC.SelectObject(&m_fntArial);
  460.                        
  461.                 }
  462.                 else if(c == m_Escapes[GROUP_TITLE]) {
  463.                         rmcode = 1;
  464.                         bItalic = FALSE;
  465.                         bUnderline = FALSE;
  466.                         m_nCurrentFontHeight = m_TextHeights[GROUP_TITLE_HEIGHT];
  467.                            bSuccess = m_fntArial.CreateFont(m_TextHeights[GROUP_TITLE_HEIGHT], 0, 0, 0,
  468.                                                                    FW_BOLD, bItalic, bUnderline, 0,
  469.                                                                    ANSI_CHARSET,
  470.                            OUT_DEFAULT_PRECIS,
  471.                            CLIP_DEFAULT_PRECIS,
  472.                            PROOF_QUALITY,
  473.                            VARIABLE_PITCH | 0x04 | FF_DONTCARE,
  474.                            (LPSTR)"Arial");
  475.                         memDC.SetTextColor(m_Colors[GROUP_TITLE_COLOR]);
  476.                         if (pOldFont != NULL) memDC.SelectObject(pOldFont);
  477.                         pOldFont = memDC.SelectObject(&m_fntArial);
  478.                 }
  479.                 else if(c == m_Escapes[TOP_LEVEL_TITLE]) {
  480.                         rmcode = 1;
  481.                         bItalic = FALSE;
  482. //                        bUnderline = TRUE;
  483.                         bUnderline = FALSE;
  484.                         m_nCurrentFontHeight = m_TextHeights[TOP_LEVEL_TITLE_HEIGHT];
  485.                         bSuccess = m_fntArial.CreateFont(m_TextHeights[TOP_LEVEL_TITLE_HEIGHT], 0, 0, 0,
  486.                                                                 FW_BOLD, bItalic, bUnderline, 0,
  487.                                                                 ANSI_CHARSET,
  488.                                OUT_DEFAULT_PRECIS,
  489.                                CLIP_DEFAULT_PRECIS,
  490.                                PROOF_QUALITY,
  491.                                VARIABLE_PITCH | 0x04 | FF_DONTCARE,
  492.                                (LPSTR)"Arial");
  493.                         memDC.SetTextColor(m_Colors[TOP_LEVEL_TITLE_COLOR]);
  494.                         if (pOldFont != NULL) memDC.SelectObject(pOldFont);
  495.                         pOldFont = memDC.SelectObject(&m_fntArial);
  496.                 }
  497.                 else if(c == m_Escapes[DISPLAY_BITMAP]) {
  498.                         if (!m_bProcessingBitmap)
  499.                         {
  500.                                 CString szBitmap = m_szWork.Left(m_szWork.GetLength()-1);
  501.                                 if(m_bmpWork.LoadBitmap((const char *)szBitmap)) {
  502.                                         BITMAP                 m_bmpInfo;

  503.                                            m_bmpWork.GetObject(sizeof(BITMAP), &m_bmpInfo);
  504.                        
  505.                                         m_size.cx = m_bmpInfo.bmWidth;        // width  of dest rect
  506.                                         m_size.cy = m_bmpInfo.bmHeight;
  507.                                         // upper left point of dest
  508.                                         m_pt.x = (m_ClientRect.right -
  509.                                                         ((m_ClientRect.Width())/2) - (m_size.cx/2));
  510.                                         m_pt.y = m_ClientRect.bottom;
  511.                                
  512.                                         m_bProcessingBitmap = TRUE;
  513.                                         if (pOldMemDC2Bitmap != NULL) memDC2.SelectObject(pOldMemDC2Bitmap);
  514.                                         pOldMemDC2Bitmap = memDC2.SelectObject(&m_bmpWork);
  515.                                 }
  516.                                 else
  517.                                         c = ' ';
  518.                         }
  519.                         else {
  520.                                 if (pOldMemDC2Bitmap != NULL) memDC2.SelectObject(pOldMemDC2Bitmap);
  521.                                 pOldMemDC2Bitmap = memDC2.SelectObject(&m_bmpWork);
  522.                         }
  523.                 }
  524.                 else {
  525.                         bItalic = FALSE;
  526.                         bUnderline = FALSE;
  527.                         m_nCurrentFontHeight = m_TextHeights[NORMAL_TEXT_HEIGHT];
  528.                            bSuccess = m_fntArial.CreateFont(m_TextHeights[NORMAL_TEXT_HEIGHT], 0, 0, 0,
  529.                                                                    FW_THIN, bItalic, bUnderline, 0,
  530.                                                                    ANSI_CHARSET,
  531.                            OUT_DEFAULT_PRECIS,
  532.                            CLIP_DEFAULT_PRECIS,
  533.                            PROOF_QUALITY,
  534.                            VARIABLE_PITCH | 0x04 | FF_DONTCARE,
  535.                            (LPSTR)"Arial");
  536.                         memDC.SetTextColor(m_Colors[NORMAL_TEXT_COLOR]);
  537.                         if (pOldFont != NULL) memDC.SelectObject(pOldFont);
  538.                         pOldFont = memDC.SelectObject(&m_fntArial);
  539.                 }
  540.         }

  541. #ifndef SCROLLDC
  542.         CRect r1(m_ScrollRect);
  543.         r1.top = r1.bottom-abs(m_ScrollAmount);
  544. #endif

  545.         if(m_Gradient && m_bitmap.m_hObject == NULL)
  546.                 FillGradient(&memDC, &m_ScrollRect, &r1, m_Colors[BACKGROUND_COLOR]);
  547.         else
  548.                 memDC.FillSolidRect(&r1,BackColor);
  549.         memDC.SetBkMode(TRANSPARENT);

  550.         if (!m_bProcessingBitmap)
  551.         {
  552.                 if(bCheck) {
  553.                         CSize size = memDC.GetTextExtent((LPCTSTR)m_szWork,m_szWork.GetLength()-rmcode);
  554.                         if(size.cx > n_MaxWidth) {
  555.                                 n_MaxWidth = (size.cx > m_ScrollRect.Width())? m_ScrollRect.Width():size.cx;
  556.                                 m_ClientRect.left = (m_ScrollRect.Width()-n_MaxWidth)/2;
  557.                                 m_ClientRect.right = m_ClientRect.left + n_MaxWidth;
  558.                         }
  559.                                
  560.                 }
  561.                 CRect r(m_ClientRect);
  562.                 r.top = r.bottom-m_nClip;
  563.                 int x = memDC.DrawText((const char *)m_szWork,m_szWork.GetLength()-rmcode,&r,DT_TOP|DT_CENTER|
  564.                                         DT_NOPREFIX | DT_SINGLELINE);       
  565.                 m_bDrawText=FALSE;
  566.         }
  567.         else
  568.         {
  569.                 if(bCheck) {
  570.                         CSize size = memDC.GetTextExtent((LPCTSTR)m_szWork,m_szWork.GetLength()-rmcode);
  571.                         if(m_size.cx > n_MaxWidth) {
  572.                                 n_MaxWidth = (m_size.cx > m_ScrollRect.Width())? m_ScrollRect.Width():m_size.cx;
  573.                                 m_ClientRect.left = (m_ScrollRect.Width()-n_MaxWidth)/2;
  574.                                 m_ClientRect.right = m_ClientRect.left + n_MaxWidth;
  575.                         }
  576.                 }
  577.                 CRect r( m_pt.x, m_pt.y-m_nClip, m_pt.x+ m_size.cx, m_pt.y);
  578.                 DrawBitmap(&memDC, &memDC2, &r);
  579. //            memDC.BitBlt( m_pt.x, m_pt.y-m_nClip, m_size.cx, m_nClip,
  580. //                           &memDC2, 0, 0, SRCCOPY );
  581.                 if (m_nClip >= m_size.cy)
  582.                 {
  583.                         m_bmpWork.DeleteObject();
  584.                         m_bProcessingBitmap = FALSE;
  585.                         m_nClip=0;
  586.                         m_szWork.Empty();
  587.                         m_nCounter=1;
  588.                 }
  589.         }

  590.         if (pOldMemDC2Bitmap != NULL) memDC2.SelectObject(pOldMemDC2Bitmap);
  591.         if (pOldFont != NULL) memDC.SelectObject(pOldFont);
  592.         memDC.SelectObject(pOldMemDCBitmap);
  593. }

  594. void CCreditStatic::DrawCredit(CDC* pDC, CRect& m_ScrollRect)
  595. {
  596.         if(m_BmpMain.m_hObject != NULL) return;

  597.         CDC memDC,memDC2;
  598.     memDC.CreateCompatibleDC(pDC);
  599.     memDC2.CreateCompatibleDC(pDC);
  600.         COLORREF BackColor = (m_bTransparent && m_bitmap.m_hObject != NULL)? RGB(192,192,192) : m_Colors[BACKGROUND_COLOR];
  601.    
  602.         CBitmap *pOldMemDCBitmap = NULL;

  603.         m_BmpMain.CreateCompatibleBitmap( pDC, m_ScrollRect.Width(), m_ScrollRect.Height() );
  604.         pOldMemDCBitmap = (CBitmap*)memDC.SelectObject(&m_BmpMain);

  605.         if(m_Gradient && m_bitmap.m_hObject == NULL)
  606.                 FillGradient(&memDC, &m_ScrollRect, &m_ScrollRect, m_Colors[BACKGROUND_COLOR]);
  607.         else
  608.                 memDC.FillSolidRect(&m_ScrollRect, BackColor);

  609.         POSITION pos = m_ArrCredit.GetHeadPosition();
  610.         int height = 0;
  611.         while(pos != NULL && height <= m_ScrollRect.Height()) {
  612.                 CString m_szWork = m_ArrCredit.GetNext(pos);
  613.                 CFont        m_fntArial;
  614.                 CFont        *pOldFont = NULL;
  615.                 CBitmap        *pOldMemDC2Bitmap = NULL;
  616.                
  617.                 CDC memDC2;
  618.                 memDC2.CreateCompatibleDC(pDC);
  619.                 //*********************************************************************
  620.                 //        FONT SELECTION
  621.        
  622.        
  623.                 BOOL bSuccess = FALSE;
  624.                 BOOL bIsBitmap = FALSE;
  625.                
  626.                 BOOL bUnderline;
  627.                 BOOL bItalic;
  628.                 int rmcode = 0;
  629.         CBitmap bitmap;

  630.                 if (!m_szWork.IsEmpty()) {
  631.                         char c = m_szWork[m_szWork.GetLength()-1];
  632.                         if(c == m_Escapes[TOP_LEVEL_GROUP]) {
  633.                                 rmcode = 1;
  634.                                 bItalic = FALSE;
  635.                                 bUnderline = FALSE;
  636.                                 m_nCurrentFontHeight = m_TextHeights[TOP_LEVEL_GROUP_HEIGHT];
  637.                                    bSuccess = m_fntArial.CreateFont(m_TextHeights[TOP_LEVEL_GROUP_HEIGHT], 0, 0, 0,
  638.                                                                    FW_BOLD, bItalic, bUnderline, 0,
  639.                                                                    ANSI_CHARSET,
  640.                            OUT_DEFAULT_PRECIS,
  641.                            CLIP_DEFAULT_PRECIS,
  642.                            PROOF_QUALITY,
  643.                            VARIABLE_PITCH | 0x04 | FF_DONTCARE,
  644.                            (LPSTR)"Arial");
  645.                                 memDC.SetTextColor(m_Colors[TOP_LEVEL_GROUP_COLOR]);
  646.                                 pOldFont = memDC.SelectObject(&m_fntArial);
  647.                
  648.                         }
  649.                         else if(c == m_Escapes[GROUP_TITLE]) {
  650.                                 rmcode = 1;
  651.                                 bItalic = FALSE;
  652.                                 bUnderline = FALSE;
  653.                                 m_nCurrentFontHeight = m_TextHeights[GROUP_TITLE_HEIGHT];
  654.                                    bSuccess = m_fntArial.CreateFont(m_TextHeights[GROUP_TITLE_HEIGHT], 0, 0, 0,
  655.                                                                    FW_BOLD, bItalic, bUnderline, 0,
  656.                                                                    ANSI_CHARSET,
  657.                            OUT_DEFAULT_PRECIS,
  658.                            CLIP_DEFAULT_PRECIS,
  659.                            PROOF_QUALITY,
  660.                            VARIABLE_PITCH | 0x04 | FF_DONTCARE,
  661.                            (LPSTR)"Arial");
  662.                                 memDC.SetTextColor(m_Colors[GROUP_TITLE_COLOR]);
  663.                                 pOldFont = memDC.SelectObject(&m_fntArial);
  664.                         }
  665.                         else if(c == m_Escapes[TOP_LEVEL_TITLE]) {
  666.                                 rmcode = 1;
  667.                                 bItalic = FALSE;
  668.         //                        bUnderline = TRUE;
  669.                                 bUnderline = FALSE;
  670.                                 m_nCurrentFontHeight = m_TextHeights[TOP_LEVEL_TITLE_HEIGHT];
  671.                                 bSuccess = m_fntArial.CreateFont(m_TextHeights[TOP_LEVEL_TITLE_HEIGHT], 0, 0, 0,
  672.                                                                 FW_BOLD, bItalic, bUnderline, 0,
  673.                                                                 ANSI_CHARSET,
  674.                                OUT_DEFAULT_PRECIS,
  675.                                CLIP_DEFAULT_PRECIS,
  676.                                PROOF_QUALITY,
  677.                                VARIABLE_PITCH | 0x04 | FF_DONTCARE,
  678.                                (LPSTR)"Arial");
  679.                                 memDC.SetTextColor(m_Colors[TOP_LEVEL_TITLE_COLOR]);
  680.                                 pOldFont = memDC.SelectObject(&m_fntArial);
  681.                         }
  682.                         else if(c == m_Escapes[DISPLAY_BITMAP]) {
  683.                                 CString szBitmap = m_szWork.Left(m_szWork.GetLength()-1);
  684.                                 if(bitmap.LoadBitmap((const char *)szBitmap)) {
  685.                                         BITMAP                 m_bmpInfo;

  686.                                            bitmap.GetObject(sizeof(BITMAP), &m_bmpInfo);
  687.                        
  688.                                         m_size.cx = m_bmpInfo.bmWidth;        // width  of dest rect
  689.                                         m_size.cy = m_bmpInfo.bmHeight;
  690.                                         // upper left point of dest
  691.                                         m_pt.x = (m_ScrollRect.right -
  692.                                                 ((m_ScrollRect.Width())/2) - (m_size.cx/2));
  693.                                         m_pt.y = height;
  694.                                         pOldMemDC2Bitmap = memDC2.SelectObject(&bitmap);
  695.                                         bIsBitmap = TRUE;
  696.                                 }
  697.                                 else
  698.                                                 c = ' ';
  699.                         }
  700.                         else {
  701.                                 bItalic = FALSE;
  702.                                 bUnderline = FALSE;
  703.                                 m_nCurrentFontHeight = m_TextHeights[NORMAL_TEXT_HEIGHT];
  704.                                    bSuccess = m_fntArial.CreateFont(m_TextHeights[NORMAL_TEXT_HEIGHT], 0, 0, 0,
  705.                                                                    FW_THIN, bItalic, bUnderline, 0,
  706.                                                                    ANSI_CHARSET,
  707.                            OUT_DEFAULT_PRECIS,
  708.                            CLIP_DEFAULT_PRECIS,
  709.                            PROOF_QUALITY,
  710.                            VARIABLE_PITCH | 0x04 | FF_DONTCARE,
  711.                            (LPSTR)"Arial");
  712.                                 memDC.SetTextColor(m_Colors[NORMAL_TEXT_COLOR]);
  713.                                 pOldFont = memDC.SelectObject(&m_fntArial);
  714.                         }
  715.                 }

  716.                 memDC.SetBkMode(TRANSPARENT);

  717.                 if (!bIsBitmap)
  718.                 {                               
  719.                         CRect r(m_ScrollRect);
  720.                         r.top = height;
  721.                         CSize size;
  722.                         if(m_szWork.GetLength()-rmcode != 0)
  723.                         {
  724.                                 int x = memDC.DrawText((const char *)m_szWork,m_szWork.GetLength()-rmcode,&r,DT_TOP|DT_CENTER|
  725.                                                 DT_NOPREFIX | DT_SINGLELINE);       
  726.                                 size = memDC.GetTextExtent((LPCTSTR)m_szWork,m_szWork.GetLength()-rmcode);
  727.                         }
  728.                         else
  729.                                 size = memDC.GetTextExtent((LPCTSTR)"W",1);
  730.                         height += size.cy;
  731.                 }
  732.                 else
  733.                 {
  734.                         CRect r( m_pt.x, m_pt.y, m_pt.x + m_size.cx, m_pt.y + m_size.cy);
  735.                         DrawBitmap(&memDC, &memDC2, &r);
  736. //                    memDC.BitBlt( m_pt.x, m_pt.y, m_size.cx, m_size.cy, &memDC2, 0, 0, SRCCOPY );
  737.                         height += m_size.cy;
  738.                 }
  739.                 if (pOldMemDC2Bitmap != NULL) memDC2.SelectObject(pOldMemDC2Bitmap);
  740.                 if (pOldFont != NULL) memDC.SelectObject(pOldFont);
  741.         }
  742.         memDC.SelectObject(pOldMemDCBitmap);
  743. }

  744. void CCreditStatic::OnDestroy()
  745. {
  746.         CStatic::OnDestroy();

  747.         m_ArrCredit.RemoveAll();

  748.         if(TimerOn)
  749.                 ASSERT(KillTimer(DISPLAY_TIMER_ID));       
  750. }

  751. BOOL CCreditStatic::SetBkImage(UINT nIDResource)
  752. {
  753.     return SetBkImage( (LPCTSTR)nIDResource );
  754. }

  755. BOOL CCreditStatic::SetBkImage(LPCTSTR lpszResourceName)
  756. {

  757.     // If this is not the first call then Delete GDI objects
  758.     if( m_bitmap.m_hObject != NULL )
  759.                 m_bitmap.DeleteObject();
  760.     if( m_pal.m_hObject != NULL )
  761.                 m_pal.DeleteObject();
  762.    
  763.    
  764.     HBITMAP hBmp = (HBITMAP)::LoadImage( AfxGetInstanceHandle(),
  765.             lpszResourceName, IMAGE_BITMAP, 0,0, LR_CREATEDIBSECTION );

  766.      if( hBmp == NULL )
  767.         return FALSE;

  768.         m_bitmap.Attach( hBmp );
  769.     BITMAP bm;
  770.     m_bitmap.GetBitmap( &bm );
  771.     m_cxBitmap = bm.bmWidth;
  772.     m_cyBitmap = bm.bmHeight;

  773.     // Create a logical palette for the bitmap
  774.     DIBSECTION ds;
  775.     BITMAPINFOHEADER &bmInfo = ds.dsBmih;
  776.     m_bitmap.GetObject( sizeof(ds), &ds );

  777.     int nColors = bmInfo.biClrUsed ? bmInfo.biClrUsed : 1 << bmInfo.biBitCount;

  778.     // Create a halftone palette if colors > 256.
  779.     CClientDC dc(NULL);             // Desktop DC
  780.     if( nColors > 256 )
  781.         m_pal.CreateHalftonePalette( &dc );
  782.     else
  783.     {
  784.         // Create the palette

  785.         RGBQUAD *pRGB = new RGBQUAD[nColors];
  786.         CDC memDC;
  787.         memDC.CreateCompatibleDC(&dc);

  788.         CBitmap* pOldMemDCBitmap = memDC.SelectObject( &m_bitmap );
  789.         ::GetDIBColorTable( memDC, 0, nColors, pRGB );

  790.         UINT nSize = sizeof(LOGPALETTE) + (sizeof(PALETTEENTRY) * nColors);
  791.         LOGPALETTE *pLP = (LOGPALETTE *) new BYTE[nSize];

  792.         pLP->palVersion = 0x300;
  793.         pLP->palNumEntries = nColors;

  794.         for( int i=0; i < nColors; i++)
  795.         {
  796.             pLP->palPalEntry[i].peRed = pRGB[i].rgbRed;
  797.             pLP->palPalEntry[i].peGreen = pRGB[i].rgbGreen;
  798.             pLP->palPalEntry[i].peBlue = pRGB[i].rgbBlue;
  799.             pLP->palPalEntry[i].peFlags = 0;
  800.         }

  801.         m_pal.CreatePalette( pLP );

  802.                 memDC.SelectObject(pOldMemDCBitmap);
  803.         delete[] pLP;
  804.         delete[] pRGB;
  805.     }
  806. //    Invalidate();

  807.     return TRUE;
  808. }
复制代码


回复

使用道具 举报

快速回复 返回列表 客服中心 搜索