找回密码
 本站已关闭注册功能,有需求联系qq/微信263946146

QQ登录

只需一步，快速开始

首页 › 工控编程 › 上位机 › 上位机MFC滚动文本实例
返回列表 发新帖

上位机MFC滚动文本实例

[ 复制链接 ]
qq263946146 2019-7-9 11:30:48 显示全部楼层 阅读模式 打印 上一主题 下一主题
效果演示
当前程序基于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_

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

  10. #define DISPLAY_SLOW                0
  11. #define DISPLAY_MEDIUM                1
  12. #define DISPLAY_FAST                2

  14. #define BACKGROUND_COLOR        0
  15. #define TOP_LEVEL_TITLE_COLOR        1
  16. #define TOP_LEVEL_GROUP_COLOR   2
  17. #define GROUP_TITLE_COLOR       3
  18. #define NORMAL_TEXT_COLOR                4

  20. #define TOP_LEVEL_TITLE_HEIGHT        0               
  21. #define TOP_LEVEL_GROUP_HEIGHT  1     
  22. #define GROUP_TITLE_HEIGHT            2     
  23. #define        NORMAL_TEXT_HEIGHT                3

  25. #define TOP_LEVEL_TITLE                        0   // '\t'
  26. #define TOP_LEVEL_GROUP         1   // '\n'
  27. #define GROUP_TITLE                   2   // '\r'
  28. #define DISPLAY_BITMAP                        3   // '^'

  30. #define GRADIENT_NONE                        0
  31. #define GRADIENT_RIGHT_DARK                1
  32. #define GRADIENT_RIGHT_LIGHT        2
  33. #define GRADIENT_LEFT_DARK                3
  34. #define GRADIENT_LEFT_LIGHT                4

  36. class CCreditStatic : public CStatic
  37. {
  38. protected:
  39.         COLORREF    m_Colors[5];
  40.         int         m_TextHeights[4];
  41.             TCHAR       m_Escapes[4];
  42.         int         m_DisplaySpeed[3],m_CurrentSpeed;
  43. //         CRect       m_ScrollRect;                   // rect of Static Text frame
  44.         CStringList m_ArrCredit;
  45.         CString                m_szWork;
  46.         int         m_nCounter;                   // work ints
  47.         POSITION    m_ArrIndex;
  48.         BOOL        m_bFirstTime;
  49.         BOOL        m_bDrawText;
  50.         int         m_nClip,m_ScrollAmount;
  51.         int         m_nCurrentFontHeight;

  53.         CBitmap     m_bmpWork;                  // bitmap holder
  54.         CBitmap                m_BmpMain;                  // bitmap holder

  56.         CSize                 m_size;                     // drawing helpers
  57.         CPoint                 m_pt;
  58.         BOOL                 m_bProcessingBitmap;
  59.         CPalette        m_pal;
  60.         CBitmap                m_bitmap;
  61.         int m_cxBitmap, m_cyBitmap;
  62.         BOOL                m_bFirstTurn;
  63.         UINT        m_Gradient;
  64.         BOOL                m_bTransparent;
  65.         int                        n_MaxWidth;
  66.         UINT        TimerOn;
  67. // Construction
  68. public:
  69.         CCreditStatic();

  71. // Attributes
  72. public:

  74. // Operations
  75. public:
  76.         BOOL StartScrolling();
  77.         void EndScrolling();
  78.         void SetCredits(LPCTSTR credits, char delimiter = '|');
  79.         void SetCredits(UINT nID, char delimiter = '|');
  80.         void SetSpeed(UINT index, int speed = 0);
  81.         void SetColor(UINT index, COLORREF col);
  82.         void SetTextHeight(UINT index, int height);
  83.         void SetEscape(UINT index, char escape);
  84.         void SetGradient(UINT value = GRADIENT_RIGHT_DARK);
  85.         BOOL SetBkImage(UINT nIDResource);
  86.         BOOL SetBkImage(LPCTSTR lpszResourceName);
  87.         void SetTransparent(BOOL bTransparent = TRUE);
  88. // Overrides
  89.         // ClassWizard generated virtual function overrides
  90.         //{{AFX_VIRTUAL(CCreditStatic)
  91.         //}}AFX_VIRTUAL

  93. // Implementation
  94. public:
  95.         virtual ~CCreditStatic();

  97.         // Generated message map functions
  98. protected:
  99.         void MoveCredit(CDC *pDC, CRect& r, CRect& r2, BOOL bCheck);
  100.         void AddBackGround(CDC* pDC, CRect& m_ScrollRect, CRect& m_ClientRect);
  101.         void DrawCredit(CDC* pDC, CRect& m_ScrollRect);
  102.         void FillGradient(CDC *pDC, CRect *m_ScrollRect, CRect *m_FillRect, COLORREF color);
  103.         void DrawBitmap(CDC* pDC, CDC* pDC2, CRect *rBitmap);

  105.         //{{AFX_MSG(CCreditStatic)
  106.         afx_msg void OnPaint();
  107.         afx_msg BOOL OnEraseBkgnd(CDC* pDC);
  108.         afx_msg void OnTimer(UINT nIDEvent);
  109.         afx_msg void OnDestroy();
  110.         //}}AFX_MSG

  112.         DECLARE_MESSAGE_MAP()
  113. };

  115. /////////////////////////////////////////////////////////////////////////////

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

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

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

  10. #define  DISPLAY_TIMER_ID                150                // timer id
  11. /////////////////////////////////////////////////////////////////////////////
  12. // CCreditStatic

  14. CCreditStatic::CCreditStatic()
  15. {

  17.         m_Colors[0] = RGB(0,0,0);       // Black
  18.         m_Colors[1] = RGB(255,0,0);     // Red
  19.         m_Colors[2] = RGB(255,255,0);   // Yellow
  20.         m_Colors[3] = RGB(0,255,255);   // Turquoise
  21.         m_Colors[4] = RGB(255,255,255); // White

  23.         m_TextHeights[0] = 21;
  24.         m_TextHeights[1] = 19;
  25.         m_TextHeights[2] = 17;
  26.         m_TextHeights[3] = 15;
  27.         m_nCurrentFontHeight = m_TextHeights[NORMAL_TEXT_HEIGHT];


  30.         m_Escapes[0] = '\t';
  31.         m_Escapes[1] = '\n';
  32.         m_Escapes[2] = '\r';
  33.         m_Escapes[3] = '^';

  35.         m_DisplaySpeed[0] = 70;
  36.         m_DisplaySpeed[1] = 40;
  37.         m_DisplaySpeed[2] = 10;

  39.         m_CurrentSpeed = 1;
  40.         m_ScrollAmount = -1;
  41.         m_bProcessingBitmap = FALSE;

  43.         m_ArrIndex = NULL;
  44.         m_nCounter = 1;
  45.         m_nClip = 0;

  47.         m_bFirstTime = TRUE;
  48.         m_bDrawText = FALSE;
  49.         m_bFirstTurn = TRUE;
  50.         m_Gradient = GRADIENT_NONE;
  51.         m_bTransparent = FALSE;
  52.         n_MaxWidth = 0;
  53.         TimerOn = 0;
  54. }

  56. CCreditStatic::~CCreditStatic()
  57. {
  58. }


  61. BEGIN_MESSAGE_MAP(CCreditStatic, CStatic)
  62.         //{{AFX_MSG_MAP(CCreditStatic)
  63.         ON_WM_PAINT()
  64.         ON_WM_ERASEBKGND()
  65.         ON_WM_TIMER()
  66.         ON_WM_DESTROY()
  67.         //}}AFX_MSG_MAP
  68. END_MESSAGE_MAP()

  70. /////////////////////////////////////////////////////////////////////////////
  71. // CCreditStatic message handlers

  73. BOOL CCreditStatic::StartScrolling()
  74. {
  75.         if(m_ArrCredit.IsEmpty())
  76.                 return FALSE;

  78.         if(m_BmpMain.m_hObject != NULL) {
  79.                 m_BmpMain.DeleteObject();
  80.                 m_BmpMain.m_hObject = NULL;
  81.         }
  82.        
  83.         TimerOn = SetTimer(DISPLAY_TIMER_ID,m_DisplaySpeed[m_CurrentSpeed],NULL);
  84.     ASSERT(TimerOn != 0);

  86.         m_ArrIndex = m_ArrCredit.GetHeadPosition();
  87.         m_nCounter = 1;
  88.         m_nClip = 0;

  90.         m_bFirstTime = TRUE;
  91.         m_bDrawText = FALSE;

  93.         return TRUE;
  94. }

  96. void CCreditStatic::EndScrolling()
  97. {
  98.         KillTimer(DISPLAY_TIMER_ID);
  99.         TimerOn = 0;

  101.         if(m_BmpMain.m_hObject != NULL) {
  102.                 m_BmpMain.DeleteObject();
  103.                 m_BmpMain.m_hObject = NULL;
  104.         }
  105. }

  107. void CCreditStatic::SetCredits(LPCTSTR credits,char delimiter)
  108. {
  109.         char *str,*ptr1,*ptr2;
  110.    
  111.         ASSERT(credits);

  113.         if((str = strdup(credits)) == NULL)
  114.                 return;

  116.         m_ArrCredit.RemoveAll();

  118.         ptr1 = str;
  119.         while((ptr2 = strchr(ptr1,delimiter)) != NULL) {
  120.                 *ptr2 = '\0';
  121.                 m_ArrCredit.AddTail(ptr1);
  122.                 ptr1 = ptr2+1;
  123.         }
  124.         m_ArrCredit.AddTail(ptr1);

  126.         free(str);

  128.         m_ArrIndex = m_ArrCredit.GetHeadPosition();
  129.         m_nCounter = 1;
  130.         m_nClip = 0;

  132.         m_bFirstTime = TRUE;
  133.         m_bDrawText = FALSE;
  134. }

  136. void CCreditStatic::SetCredits(UINT nID,char delimiter)
  137. {
  138.         CString credits;
  139.         if(!credits.LoadString(nID))
  140.                 return;

  142.         SetCredits((LPCTSTR)credits, delimiter);
  143. }

  145. void CCreditStatic::SetSpeed(UINT index, int speed)
  146. {
  147.         ASSERT(index <= DISPLAY_FAST);

  149.         if(speed)
  150.                 m_DisplaySpeed[index] = speed;

  152.         m_CurrentSpeed = index;
  153. }

  155. void CCreditStatic::SetColor(UINT index, COLORREF col)
  156. {
  157.         ASSERT(index <= NORMAL_TEXT_COLOR);

  159.         m_Colors[index] = col;
  160. }

  162. void CCreditStatic::SetTextHeight(UINT index, int height)
  163. {
  164.         ASSERT(index <= NORMAL_TEXT_HEIGHT);

  166.         m_TextHeights[index] = height;
  167. }

  169. void CCreditStatic::SetEscape(UINT index, char escape)
  170. {
  171.         ASSERT(index <= DISPLAY_BITMAP);

  173.         m_Escapes[index] = escape;
  174. }

  176. void CCreditStatic::SetGradient(UINT value)
  177. {
  178.         ASSERT(value <= GRADIENT_LEFT_LIGHT);

  180.         m_Gradient = value;
  181. }

  183. void CCreditStatic::SetTransparent(BOOL bTransparent)
  184. {
  185.         m_bTransparent = bTransparent;
  186. }

  188. void CCreditStatic::OnPaint()
  189. {
  190.         CPaintDC dc(this); // device context for painting
  191.        
  192.         if(TimerOn) return;

  194.         CDC memDC;
  195.         memDC.CreateCompatibleDC(&dc);

  197.         CBitmap *pOldMemDCBitmap = NULL;
  198.         CRect m_ScrollRect;
  199.         GetClientRect(&m_ScrollRect);

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

  203.                 CDC memDC2;
  204.                 CBitmap bitmap;
  205.                 memDC2.CreateCompatibleDC(&dc);
  206.                 bitmap.CreateCompatibleBitmap( &dc, m_ScrollRect.Width(), m_ScrollRect.Height() );
  207.                 CBitmap *pOldMemDC2Bitmap = (CBitmap*)memDC2.SelectObject(&bitmap);
  208.                
  209.                 DrawCredit(&memDC2, m_ScrollRect);
  210.                 AddBackGround(&memDC2, m_ScrollRect, m_ScrollRect);

  212.                 pOldMemDCBitmap = (CBitmap*)memDC.SelectObject(&m_BmpMain);
  213.         memDC.BitBlt( 0, 0, m_ScrollRect.Width(), m_ScrollRect.Height(),
  214.                                         &memDC2, 0, 0, SRCCOPY );
  215.                 memDC2.SelectObject(pOldMemDC2Bitmap);
  216.         }
  217.         else
  218.                 pOldMemDCBitmap = (CBitmap*)memDC.SelectObject(&m_BmpMain);
  219.       
  220.         dc.BitBlt( 0, 0, m_ScrollRect.Width(), m_ScrollRect.Height(),
  221.                &memDC, 0, 0, SRCCOPY );
  222. }

  224. BOOL CCreditStatic::OnEraseBkgnd(CDC* pDC)
  225. {
  226.         return TRUE;
  227.        
  228. //        return CStatic::OnEraseBkgnd(pDC);
  229. }

  231. //************************************************************************
  232. //         OnTimer
  233. //
  234. //                 On each of the display timers, scroll the window 1 unit. Each 20
  235. //      units, fetch the next array element and load into work string. Call
  236. //      Invalidate and UpdateWindow to invoke the OnPaint which will paint
  237. //      the contents of the newly updated work string.
  238. //************************************************************************
  239. void CCreditStatic::OnTimer(UINT nIDEvent)
  240. {
  241.         if (nIDEvent != DISPLAY_TIMER_ID)
  242.         {
  243.                 CStatic::OnTimer(nIDEvent);
  244.                 return;
  245.         }

  247.         BOOL bCheck = FALSE;

  249.         if (!m_bProcessingBitmap) {
  250.                 if (m_nCounter++ % m_nCurrentFontHeight == 0)         // every x timer events, show new line
  251.                 {
  252.                         m_nCounter=1;
  253.                         m_szWork = m_ArrCredit.GetNext(m_ArrIndex);
  254.                         if(m_bFirstTurn)
  255.                                 bCheck = TRUE;
  256.                         if(m_ArrIndex == NULL) {
  257.                                 m_bFirstTurn = FALSE;
  258.                                 m_ArrIndex = m_ArrCredit.GetHeadPosition();
  259.                         }
  260.                         m_nClip = 0;
  261.                         m_bDrawText=TRUE;
  262.                 }
  263.         }
  264.        
  265.     CClientDC dc(this);
  266.         CRect m_ScrollRect;
  267.         GetClientRect(&m_ScrollRect);

  269.         CRect m_ClientRect(m_ScrollRect);
  270.         m_ClientRect.left = (m_ClientRect.Width()-n_MaxWidth)/2;
  271.         m_ClientRect.right = m_ClientRect.left + n_MaxWidth;

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

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

  277.         CStatic::OnTimer(nIDEvent);
  278. }

  280. void CCreditStatic::AddBackGround(CDC* pDC, CRect& m_ScrollRect, CRect& m_ClientRect)
  281. {
  282.         CDC memDC;
  283.         memDC.CreateCompatibleDC( pDC );

  285.     if( m_bitmap.m_hObject == NULL )
  286.         {
  287.         CBitmap* pOldBitmap = memDC.SelectObject( &m_BmpMain );
  288.         pDC->BitBlt( 0, 0, m_ScrollRect.Width(), m_ScrollRect.Height(),
  289.                                         &memDC, 0, 0, SRCCOPY );
  290.                 memDC.SelectObject(pOldBitmap);
  291.                 return;
  292.         }

  294.    // Draw bitmap in the background if one has been set
  295.                 // Now create a mask
  296.         CBitmap bitmap;
  297.         bitmap.CreateCompatibleBitmap( pDC, m_ClientRect.Width(), m_ClientRect.Height() );
  298.         CBitmap* pOldMemDCBitmap = memDC.SelectObject( &bitmap );
  299.                
  300.         CDC tempDC;
  301.         tempDC.CreateCompatibleDC(pDC);
  302.         CBitmap* pOldTempDCBitmap = tempDC.SelectObject( &m_BmpMain );

  304.         memDC.BitBlt( 0, 0, m_ClientRect.Width(), m_ClientRect.Height(), &tempDC,
  305.                       m_ClientRect.left, m_ClientRect.top, SRCCOPY );
  306.         CDC maskDC;
  307.         maskDC.CreateCompatibleDC(pDC);
  308.         CBitmap maskBitmap;

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

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

  318.         tempDC.SelectObject(pOldTempDCBitmap);
  319.         pOldTempDCBitmap = tempDC.SelectObject( &m_bitmap );

  321.         CDC imageDC;
  322.         CBitmap bmpImage;
  323.         imageDC.CreateCompatibleDC( pDC );
  324.         bmpImage.CreateCompatibleBitmap( pDC, m_ScrollRect.Width(), m_ScrollRect.Height() );
  325.         CBitmap* pOldImageDCBitmap = imageDC.SelectObject( &bmpImage );

  327.         if( pDC->GetDeviceCaps(RASTERCAPS) & RC_PALETTE && m_pal.m_hObject != NULL )
  328.         {
  329.                 pDC->SelectPalette( &m_pal, FALSE );
  330.                 pDC->RealizePalette();

  332.                 imageDC.SelectPalette( &m_pal, FALSE );
  333.         }
  334.         // Get x and y offset
  335.         // Draw bitmap in tiled manner to imageDC
  336.         for( int i = 0; i < m_ScrollRect.right; i += m_cxBitmap )
  337.                 for( int j = 0; j < m_ScrollRect.bottom; j += m_cyBitmap )
  338.                         imageDC.BitBlt( i, j, m_cxBitmap, m_cyBitmap, &tempDC, 0, 0, SRCCOPY );

  340.         // Set the background in memDC to black. Using SRCPAINT with black and any other
  341.         // color results in the other color, thus making black the transparent color
  342.         memDC.SetBkColor(RGB(0,0,0));
  343.         memDC.SetTextColor(RGB(255,255,255));
  344.         memDC.BitBlt(0, 0, m_ClientRect.Width(), m_ClientRect.Height(), &maskDC, 0, 0, SRCAND);

  346.         // Set the foreground to black. See comment above.
  347.         imageDC.SetBkColor(RGB(255,255,255));
  348.         imageDC.SetTextColor(RGB(0,0,0));
  349.         imageDC.BitBlt(m_ClientRect.left, m_ClientRect.top, m_ClientRect.Width(), m_ClientRect.Height(),
  350.                                         &maskDC, 0, 0, SRCAND);

  352.         // Combine the foreground with the background
  353.     imageDC.BitBlt(m_ClientRect.left, m_ClientRect.top, m_ClientRect.Width(), m_ClientRect.Height(),
  354.                                         &memDC, 0, 0,SRCPAINT);

  356.         // Draw the final image to the screen   
  357.         pDC->BitBlt( 0, 0, m_ScrollRect.Width(), m_ScrollRect.Height(),
  358.                                         &imageDC, 0, 0, SRCCOPY );

  360.         imageDC.SelectObject(pOldImageDCBitmap);
  361.         maskDC.SelectObject(pOldMaskDCBitmap);
  362.         tempDC.SelectObject(pOldTempDCBitmap);
  363.         memDC.SelectObject(pOldMemDCBitmap);
  364. }

  366. void CCreditStatic::DrawBitmap(CDC* pDC, CDC* pDC2, CRect *rBitmap)
  367. {
  368.         if(!m_bTransparent || m_bitmap.m_hObject != NULL) {
  369.             pDC->BitBlt( rBitmap->left, rBitmap->top, rBitmap->Width(), rBitmap->Height(),
  370.                                    pDC2, 0, 0, SRCCOPY );
  371.                 return;
  372.         }

  374.         CDC memDC;
  375.         memDC.CreateCompatibleDC( pDC );

  377.     // Now create a mask
  378.         CBitmap bitmap;
  379.         bitmap.CreateCompatibleBitmap( pDC, rBitmap->Width(), rBitmap->Height() );
  380.         CBitmap* pOldMemDCBitmap = memDC.SelectObject( &bitmap );
  381.                
  382.         memDC.BitBlt( 0, 0, rBitmap->Width(), rBitmap->Height(), pDC2, 0, 0, SRCCOPY );

  384.         CDC maskDC;
  385.         maskDC.CreateCompatibleDC(pDC);

  387.         // Create monochrome bitmap for the mask
  388.         CBitmap maskBitmap;
  389.         maskBitmap.CreateBitmap( rBitmap->Width(), rBitmap->Height(), 1, 1, NULL );
  390.         CBitmap* pOldMaskDCBitmap = maskDC.SelectObject( &maskBitmap );
  391.     memDC.SetBkColor(RGB(192,192,192));

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


  397.         CDC imageDC;
  398.         CBitmap bmpImage;
  399.         imageDC.CreateCompatibleDC( pDC );
  400.         bmpImage.CreateCompatibleBitmap( pDC, rBitmap->Width(), rBitmap->Height() );
  401.         CBitmap* pOldImageDCBitmap = imageDC.SelectObject( &bmpImage );

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

  405.         // Set the background in memDC to black. Using SRCPAINT with black and any other
  406.         // color results in the other color, thus making black the transparent color
  407.         memDC.SetBkColor(RGB(0,0,0));
  408.         memDC.SetTextColor(RGB(255,255,255));
  409.         memDC.BitBlt(0, 0, rBitmap->Width(), rBitmap->Height(), &maskDC, 0, 0, SRCAND);

  411.         // Set the foreground to black. See comment above.
  412.         imageDC.SetBkColor(RGB(255,255,255));
  413.         imageDC.SetTextColor(RGB(0,0,0));
  414.         imageDC.BitBlt(0, 0, rBitmap->Width(), rBitmap->Height(), &maskDC, 0, 0, SRCAND);

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

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

  423.         imageDC.SelectObject(pOldImageDCBitmap);
  424.         maskDC.SelectObject(pOldMaskDCBitmap);
  425.         memDC.SelectObject(pOldMemDCBitmap);
  426. }

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

  433.         WORD R = GetRValue(color);
  434.         WORD G = GetGValue(color);
  435.         WORD B = GetBValue(color);

  437.         // Determine how large each band should be in order to cover the
  438.         // client with 256 bands (one for every color intensity level)
  439.         if(m_Gradient % 2) {
  440.                 fRStep = (float)R / 255.0f;
  441.                 fGStep = (float)G / 255.0f;
  442.                 fBStep = (float)B / 255.0f;
  443.         } else {
  444.                 fRStep = (float)(255-R) / 255.0f;
  445.                 fGStep = (float)(255-G) / 255.0f;
  446.                 fBStep = (float)(255-B) / 255.0f;
  447.         }

  449.         COLORREF OldCol = pDC->GetBkColor();
  450.         // Start filling bands
  451.         fStep = (float)m_ScrollRect->Width() / 256.0f;
  452.         for(iOnBand = (256*m_FillRect->left)/m_ScrollRect->Width();
  453.                 (int)(iOnBand*fStep) < m_FillRect->right && iOnBand < 256; iOnBand++) {
  454.                 CRect r((int)(iOnBand * fStep), m_FillRect->top,
  455.                                 (int)((iOnBand+1) * fStep), m_FillRect->bottom+1);
  456.                 COLORREF col;

  458.                 switch(m_Gradient) {
  459.                 case GRADIENT_RIGHT_DARK:
  460.                         col = RGB((int)(R-iOnBand*fRStep),(int)(G-iOnBand*fGStep),(int)(B-iOnBand*fBStep));
  461.                         break;
  462.                 case GRADIENT_RIGHT_LIGHT:
  463.                         col = RGB((int)(R+iOnBand*fRStep),(int)(G+iOnBand*fGStep),(int)(B+iOnBand*fBStep));
  464.                         break;
  465.                 case GRADIENT_LEFT_DARK:
  466.                         col = RGB((int)(iOnBand*fRStep),(int)(iOnBand*fGStep),(int)(iOnBand*fBStep));
  467.                         break;
  468.                 case GRADIENT_LEFT_LIGHT:
  469.                         col = RGB(255-(int)(iOnBand*fRStep),255-(int)(iOnBand*fGStep),255-(int)(iOnBand*fBStep));
  470.                         break;
  471.                 default:
  472.                         return;
  473.                 }
  474.                 pDC->FillSolidRect(&r, col);
  475.         }
  476.         pDC->SetBkColor(OldCol);
  477. }

  479. #define SCROLLDC

  481. void CCreditStatic::MoveCredit(CDC* pDC, CRect& m_ScrollRect, CRect& m_ClientRect, BOOL bCheck)
  482. {
  483.         CDC memDC,memDC2;
  484.     memDC.CreateCompatibleDC(pDC);
  485.     memDC2.CreateCompatibleDC(pDC);
  486.    
  487.         COLORREF BackColor = (m_bTransparent && m_bitmap.m_hObject != NULL)? RGB(192,192,192) : m_Colors[BACKGROUND_COLOR];
  488.         CBitmap *pOldMemDCBitmap = NULL;
  489.         CBitmap        *pOldMemDC2Bitmap = NULL;

  491. #ifdef SCROLLDC
  492.         CRect r1;
  493. #endif

  495.         if(m_BmpMain.m_hObject == NULL) {
  496.                 m_BmpMain.CreateCompatibleBitmap( pDC, m_ScrollRect.Width(), m_ScrollRect.Height() );
  497.                 pOldMemDCBitmap = (CBitmap*)memDC.SelectObject(&m_BmpMain);
  498.                 if(m_Gradient && m_bitmap.m_hObject == NULL)
  499.                         FillGradient(&memDC, &m_ScrollRect, &m_ScrollRect,m_Colors[BACKGROUND_COLOR]);
  500.                 else
  501.                         memDC.FillSolidRect(&m_ScrollRect,BackColor);
  502.         } else
  503.                 pOldMemDCBitmap = (CBitmap*)memDC.SelectObject(&m_BmpMain);

  505.         if(m_ClientRect.Width() > 0) {
  506. #ifndef SCROLLDC
  507.                 CBitmap bitmap;
  508.                 bitmap.CreateCompatibleBitmap( pDC, m_ClientRect.Width(), m_ClientRect.Height() );
  509.                 pOldMemDC2Bitmap = memDC2.SelectObject(&bitmap);

  511.                 memDC2.BitBlt( 0, 0, m_ClientRect.Width(), m_ClientRect.Height()-abs(m_ScrollAmount),
  512.                     &memDC, m_ClientRect.left, abs(m_ScrollAmount), SRCCOPY );
  513.                 memDC.BitBlt( m_ClientRect.left, 0, m_ClientRect.Width(), m_ClientRect.Height(),
  514.                     &memDC2, 0, 0, SRCCOPY );

  516.                
  517.                 memDC2.SelectObject(pOldMemDC2Bitmap);
  518.                 pOldMemDC2Bitmap = NULL;
  519. #else
  520.                 CRgn RgnUpdate;
  521.                 memDC.ScrollDC(0,m_ScrollAmount,(LPCRECT)m_ScrollRect,(LPCRECT)m_ClientRect,&RgnUpdate,
  522.                                                 (LPRECT)r1);
  523.     }
  524.         else {
  525.                 r1 = m_ScrollRect;
  526.                 r1.top = r1.bottom-abs(m_ScrollAmount);
  527. #endif
  528.         }

  530.         m_nClip = m_nClip + abs(m_ScrollAmount);       
  531.        

  533.         //*********************************************************************
  534.         //        FONT SELECTION
  535.     CFont m_fntArial;
  536.         CFont* pOldFont = NULL;
  537.         BOOL bSuccess = FALSE;
  538.        
  539.         BOOL bUnderline;
  540.         BOOL bItalic;
  541.     int rmcode = 0;

  543.         if (!m_szWork.IsEmpty()) {
  544.                 char c = m_szWork[m_szWork.GetLength()-1];
  545.                 if(c == m_Escapes[TOP_LEVEL_GROUP]) {
  546.                         rmcode = 1;
  547.                         bItalic = FALSE;
  548.                         bUnderline = FALSE;
  549.                         m_nCurrentFontHeight = m_TextHeights[TOP_LEVEL_GROUP_HEIGHT];
  550.                            bSuccess = m_fntArial.CreateFont(m_TextHeights[TOP_LEVEL_GROUP_HEIGHT], 0, 0, 0,
  551.                                                                    FW_BOLD, bItalic, bUnderline, 0,
  552.                                                                    ANSI_CHARSET,
  553.                            OUT_DEFAULT_PRECIS,
  554.                            CLIP_DEFAULT_PRECIS,
  555.                            PROOF_QUALITY,
  556.                            VARIABLE_PITCH | 0x04 | FF_DONTCARE,
  557.                            (LPSTR)"Arial");
  558.                         memDC.SetTextColor(m_Colors[TOP_LEVEL_GROUP_COLOR]);
  559.                         if (pOldFont != NULL) memDC.SelectObject(pOldFont);
  560.                         pOldFont = memDC.SelectObject(&m_fntArial);
  561.                        
  562.                 }
  563.                 else if(c == m_Escapes[GROUP_TITLE]) {
  564.                         rmcode = 1;
  565.                         bItalic = FALSE;
  566.                         bUnderline = FALSE;
  567.                         m_nCurrentFontHeight = m_TextHeights[GROUP_TITLE_HEIGHT];
  568.                            bSuccess = m_fntArial.CreateFont(m_TextHeights[GROUP_TITLE_HEIGHT], 0, 0, 0,
  569.                                                                    FW_BOLD, bItalic, bUnderline, 0,
  570.                                                                    ANSI_CHARSET,
  571.                            OUT_DEFAULT_PRECIS,
  572.                            CLIP_DEFAULT_PRECIS,
  573.                            PROOF_QUALITY,
  574.                            VARIABLE_PITCH | 0x04 | FF_DONTCARE,
  575.                            (LPSTR)"Arial");
  576.                         memDC.SetTextColor(m_Colors[GROUP_TITLE_COLOR]);
  577.                         if (pOldFont != NULL) memDC.SelectObject(pOldFont);
  578.                         pOldFont = memDC.SelectObject(&m_fntArial);
  579.                 }
  580.                 else if(c == m_Escapes[TOP_LEVEL_TITLE]) {
  581.                         rmcode = 1;
  582.                         bItalic = FALSE;
  583. //                        bUnderline = TRUE;
  584.                         bUnderline = FALSE;
  585.                         m_nCurrentFontHeight = m_TextHeights[TOP_LEVEL_TITLE_HEIGHT];
  586.                         bSuccess = m_fntArial.CreateFont(m_TextHeights[TOP_LEVEL_TITLE_HEIGHT], 0, 0, 0,
  587.                                                                 FW_BOLD, bItalic, bUnderline, 0,
  588.                                                                 ANSI_CHARSET,
  589.                                OUT_DEFAULT_PRECIS,
  590.                                CLIP_DEFAULT_PRECIS,
  591.                                PROOF_QUALITY,
  592.                                VARIABLE_PITCH | 0x04 | FF_DONTCARE,
  593.                                (LPSTR)"Arial");
  594.                         memDC.SetTextColor(m_Colors[TOP_LEVEL_TITLE_COLOR]);
  595.                         if (pOldFont != NULL) memDC.SelectObject(pOldFont);
  596.                         pOldFont = memDC.SelectObject(&m_fntArial);
  597.                 }
  598.                 else if(c == m_Escapes[DISPLAY_BITMAP]) {
  599.                         if (!m_bProcessingBitmap)
  600.                         {
  601.                                 CString szBitmap = m_szWork.Left(m_szWork.GetLength()-1);
  602.                                 if(m_bmpWork.LoadBitmap((const char *)szBitmap)) {
  603.                                         BITMAP                 m_bmpInfo;

  605.                                            m_bmpWork.GetObject(sizeof(BITMAP), &m_bmpInfo);
  606.                        
  607.                                         m_size.cx = m_bmpInfo.bmWidth;        // width  of dest rect
  608.                                         m_size.cy = m_bmpInfo.bmHeight;
  609.                                         // upper left point of dest
  610.                                         m_pt.x = (m_ClientRect.right -
  611.                                                         ((m_ClientRect.Width())/2) - (m_size.cx/2));
  612.                                         m_pt.y = m_ClientRect.bottom;
  613.                                
  614.                                         m_bProcessingBitmap = TRUE;
  615.                                         if (pOldMemDC2Bitmap != NULL) memDC2.SelectObject(pOldMemDC2Bitmap);
  616.                                         pOldMemDC2Bitmap = memDC2.SelectObject(&m_bmpWork);
  617.                                 }
  618.                                 else
  619.                                         c = ' ';
  620.                         }
  621.                         else {
  622.                                 if (pOldMemDC2Bitmap != NULL) memDC2.SelectObject(pOldMemDC2Bitmap);
  623.                                 pOldMemDC2Bitmap = memDC2.SelectObject(&m_bmpWork);
  624.                         }
  625.                 }
  626.                 else {
  627.                         bItalic = FALSE;
  628.                         bUnderline = FALSE;
  629.                         m_nCurrentFontHeight = m_TextHeights[NORMAL_TEXT_HEIGHT];
  630.                            bSuccess = m_fntArial.CreateFont(m_TextHeights[NORMAL_TEXT_HEIGHT], 0, 0, 0,
  631.                                                                    FW_THIN, bItalic, bUnderline, 0,
  632.                                                                    ANSI_CHARSET,
  633.                            OUT_DEFAULT_PRECIS,
  634.                            CLIP_DEFAULT_PRECIS,
  635.                            PROOF_QUALITY,
  636.                            VARIABLE_PITCH | 0x04 | FF_DONTCARE,
  637.                            (LPSTR)"Arial");
  638.                         memDC.SetTextColor(m_Colors[NORMAL_TEXT_COLOR]);
  639.                         if (pOldFont != NULL) memDC.SelectObject(pOldFont);
  640.                         pOldFont = memDC.SelectObject(&m_fntArial);
  641.                 }
  642.         }

  644. #ifndef SCROLLDC
  645.         CRect r1(m_ScrollRect);
  646.         r1.top = r1.bottom-abs(m_ScrollAmount);
  647. #endif

  649.         if(m_Gradient && m_bitmap.m_hObject == NULL)
  650.                 FillGradient(&memDC, &m_ScrollRect, &r1, m_Colors[BACKGROUND_COLOR]);
  651.         else
  652.                 memDC.FillSolidRect(&r1,BackColor);
  653.         memDC.SetBkMode(TRANSPARENT);

  655.         if (!m_bProcessingBitmap)
  656.         {
  657.                 if(bCheck) {
  658.                         CSize size = memDC.GetTextExtent((LPCTSTR)m_szWork,m_szWork.GetLength()-rmcode);
  659.                         if(size.cx > n_MaxWidth) {
  660.                                 n_MaxWidth = (size.cx > m_ScrollRect.Width())? m_ScrollRect.Width():size.cx;
  661.                                 m_ClientRect.left = (m_ScrollRect.Width()-n_MaxWidth)/2;
  662.                                 m_ClientRect.right = m_ClientRect.left + n_MaxWidth;
  663.                         }
  664.                                
  665.                 }
  666.                 CRect r(m_ClientRect);
  667.                 r.top = r.bottom-m_nClip;
  668.                 int x = memDC.DrawText((const char *)m_szWork,m_szWork.GetLength()-rmcode,&r,DT_TOP|DT_CENTER|
  669.                                         DT_NOPREFIX | DT_SINGLELINE);       
  670.                 m_bDrawText=FALSE;
  671.         }
  672.         else
  673.         {
  674.                 if(bCheck) {
  675.                         CSize size = memDC.GetTextExtent((LPCTSTR)m_szWork,m_szWork.GetLength()-rmcode);
  676.                         if(m_size.cx > n_MaxWidth) {
  677.                                 n_MaxWidth = (m_size.cx > m_ScrollRect.Width())? m_ScrollRect.Width():m_size.cx;
  678.                                 m_ClientRect.left = (m_ScrollRect.Width()-n_MaxWidth)/2;
  679.                                 m_ClientRect.right = m_ClientRect.left + n_MaxWidth;
  680.                         }
  681.                 }
  682.                 CRect r( m_pt.x, m_pt.y-m_nClip, m_pt.x+ m_size.cx, m_pt.y);
  683.                 DrawBitmap(&memDC, &memDC2, &r);
  684. //            memDC.BitBlt( m_pt.x, m_pt.y-m_nClip, m_size.cx, m_nClip,
  685. //                           &memDC2, 0, 0, SRCCOPY );
  686.                 if (m_nClip >= m_size.cy)
  687.                 {
  688.                         m_bmpWork.DeleteObject();
  689.                         m_bProcessingBitmap = FALSE;
  690.                         m_nClip=0;
  691.                         m_szWork.Empty();
  692.                         m_nCounter=1;
  693.                 }
  694.         }

  696.         if (pOldMemDC2Bitmap != NULL) memDC2.SelectObject(pOldMemDC2Bitmap);
  697.         if (pOldFont != NULL) memDC.SelectObject(pOldFont);
  698.         memDC.SelectObject(pOldMemDCBitmap);
  699. }

  701. void CCreditStatic::DrawCredit(CDC* pDC, CRect& m_ScrollRect)
  702. {
  703.         if(m_BmpMain.m_hObject != NULL) return;

  705.         CDC memDC,memDC2;
  706.     memDC.CreateCompatibleDC(pDC);
  707.     memDC2.CreateCompatibleDC(pDC);
  708.         COLORREF BackColor = (m_bTransparent && m_bitmap.m_hObject != NULL)? RGB(192,192,192) : m_Colors[BACKGROUND_COLOR];
  709.    
  710.         CBitmap *pOldMemDCBitmap = NULL;

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

  715.         if(m_Gradient && m_bitmap.m_hObject == NULL)
  716.                 FillGradient(&memDC, &m_ScrollRect, &m_ScrollRect, m_Colors[BACKGROUND_COLOR]);
  717.         else
  718.                 memDC.FillSolidRect(&m_ScrollRect, BackColor);

  720.         POSITION pos = m_ArrCredit.GetHeadPosition();
  721.         int height = 0;
  722.         while(pos != NULL && height <= m_ScrollRect.Height()) {
  723.                 CString m_szWork = m_ArrCredit.GetNext(pos);
  724.                 CFont        m_fntArial;
  725.                 CFont        *pOldFont = NULL;
  726.                 CBitmap        *pOldMemDC2Bitmap = NULL;
  727.                
  728.                 CDC memDC2;
  729.                 memDC2.CreateCompatibleDC(pDC);
  730.                 //*********************************************************************
  731.                 //        FONT SELECTION
  732.        
  733.        
  734.                 BOOL bSuccess = FALSE;
  735.                 BOOL bIsBitmap = FALSE;
  736.                
  737.                 BOOL bUnderline;
  738.                 BOOL bItalic;
  739.                 int rmcode = 0;
  740.         CBitmap bitmap;

  742.                 if (!m_szWork.IsEmpty()) {
  743.                         char c = m_szWork[m_szWork.GetLength()-1];
  744.                         if(c == m_Escapes[TOP_LEVEL_GROUP]) {
  745.                                 rmcode = 1;
  746.                                 bItalic = FALSE;
  747.                                 bUnderline = FALSE;
  748.                                 m_nCurrentFontHeight = m_TextHeights[TOP_LEVEL_GROUP_HEIGHT];
  749.                                    bSuccess = m_fntArial.CreateFont(m_TextHeights[TOP_LEVEL_GROUP_HEIGHT], 0, 0, 0,
  750.                                                                    FW_BOLD, bItalic, bUnderline, 0,
  751.                                                                    ANSI_CHARSET,
  752.                            OUT_DEFAULT_PRECIS,
  753.                            CLIP_DEFAULT_PRECIS,
  754.                            PROOF_QUALITY,
  755.                            VARIABLE_PITCH | 0x04 | FF_DONTCARE,
  756.                            (LPSTR)"Arial");
  757.                                 memDC.SetTextColor(m_Colors[TOP_LEVEL_GROUP_COLOR]);
  758.                                 pOldFont = memDC.SelectObject(&m_fntArial);
  759.                
  760.                         }
  761.                         else if(c == m_Escapes[GROUP_TITLE]) {
  762.                                 rmcode = 1;
  763.                                 bItalic = FALSE;
  764.                                 bUnderline = FALSE;
  765.                                 m_nCurrentFontHeight = m_TextHeights[GROUP_TITLE_HEIGHT];
  766.                                    bSuccess = m_fntArial.CreateFont(m_TextHeights[GROUP_TITLE_HEIGHT], 0, 0, 0,
  767.                                                                    FW_BOLD, bItalic, bUnderline, 0,
  768.                                                                    ANSI_CHARSET,
  769.                            OUT_DEFAULT_PRECIS,
  770.                            CLIP_DEFAULT_PRECIS,
  771.                            PROOF_QUALITY,
  772.                            VARIABLE_PITCH | 0x04 | FF_DONTCARE,
  773.                            (LPSTR)"Arial");
  774.                                 memDC.SetTextColor(m_Colors[GROUP_TITLE_COLOR]);
  775.                                 pOldFont = memDC.SelectObject(&m_fntArial);
  776.                         }
  777.                         else if(c == m_Escapes[TOP_LEVEL_TITLE]) {
  778.                                 rmcode = 1;
  779.                                 bItalic = FALSE;
  780.         //                        bUnderline = TRUE;
  781.                                 bUnderline = FALSE;
  782.                                 m_nCurrentFontHeight = m_TextHeights[TOP_LEVEL_TITLE_HEIGHT];
  783.                                 bSuccess = m_fntArial.CreateFont(m_TextHeights[TOP_LEVEL_TITLE_HEIGHT], 0, 0, 0,
  784.                                                                 FW_BOLD, bItalic, bUnderline, 0,
  785.                                                                 ANSI_CHARSET,
  786.                                OUT_DEFAULT_PRECIS,
  787.                                CLIP_DEFAULT_PRECIS,
  788.                                PROOF_QUALITY,
  789.                                VARIABLE_PITCH | 0x04 | FF_DONTCARE,
  790.                                (LPSTR)"Arial");
  791.                                 memDC.SetTextColor(m_Colors[TOP_LEVEL_TITLE_COLOR]);
  792.                                 pOldFont = memDC.SelectObject(&m_fntArial);
  793.                         }
  794.                         else if(c == m_Escapes[DISPLAY_BITMAP]) {
  795.                                 CString szBitmap = m_szWork.Left(m_szWork.GetLength()-1);
  796.                                 if(bitmap.LoadBitmap((const char *)szBitmap)) {
  797.                                         BITMAP                 m_bmpInfo;

  799.                                            bitmap.GetObject(sizeof(BITMAP), &m_bmpInfo);
  800.                        
  801.                                         m_size.cx = m_bmpInfo.bmWidth;        // width  of dest rect
  802.                                         m_size.cy = m_bmpInfo.bmHeight;
  803.                                         // upper left point of dest
  804.                                         m_pt.x = (m_ScrollRect.right -
  805.                                                 ((m_ScrollRect.Width())/2) - (m_size.cx/2));
  806.                                         m_pt.y = height;
  807.                                         pOldMemDC2Bitmap = memDC2.SelectObject(&bitmap);
  808.                                         bIsBitmap = TRUE;
  809.                                 }
  810.                                 else
  811.                                                 c = ' ';
  812.                         }
  813.                         else {
  814.                                 bItalic = FALSE;
  815.                                 bUnderline = FALSE;
  816.                                 m_nCurrentFontHeight = m_TextHeights[NORMAL_TEXT_HEIGHT];
  817.                                    bSuccess = m_fntArial.CreateFont(m_TextHeights[NORMAL_TEXT_HEIGHT], 0, 0, 0,
  818.                                                                    FW_THIN, bItalic, bUnderline, 0,
  819.                                                                    ANSI_CHARSET,
  820.                            OUT_DEFAULT_PRECIS,
  821.                            CLIP_DEFAULT_PRECIS,
  822.                            PROOF_QUALITY,
  823.                            VARIABLE_PITCH | 0x04 | FF_DONTCARE,
  824.                            (LPSTR)"Arial");
  825.                                 memDC.SetTextColor(m_Colors[NORMAL_TEXT_COLOR]);
  826.                                 pOldFont = memDC.SelectObject(&m_fntArial);
  827.                         }
  828.                 }

  830.                 memDC.SetBkMode(TRANSPARENT);

  832.                 if (!bIsBitmap)
  833.                 {                               
  834.                         CRect r(m_ScrollRect);
  835.                         r.top = height;
  836.                         CSize size;
  837.                         if(m_szWork.GetLength()-rmcode != 0)
  838.                         {
  839.                                 int x = memDC.DrawText((const char *)m_szWork,m_szWork.GetLength()-rmcode,&r,DT_TOP|DT_CENTER|
  840.                                                 DT_NOPREFIX | DT_SINGLELINE);       
  841.                                 size = memDC.GetTextExtent((LPCTSTR)m_szWork,m_szWork.GetLength()-rmcode);
  842.                         }
  843.                         else
  844.                                 size = memDC.GetTextExtent((LPCTSTR)"W",1);
  845.                         height += size.cy;
  846.                 }
  847.                 else
  848.                 {
  849.                         CRect r( m_pt.x, m_pt.y, m_pt.x + m_size.cx, m_pt.y + m_size.cy);
  850.                         DrawBitmap(&memDC, &memDC2, &r);
  851. //                    memDC.BitBlt( m_pt.x, m_pt.y, m_size.cx, m_size.cy, &memDC2, 0, 0, SRCCOPY );
  852.                         height += m_size.cy;
  853.                 }
  854.                 if (pOldMemDC2Bitmap != NULL) memDC2.SelectObject(pOldMemDC2Bitmap);
  855.                 if (pOldFont != NULL) memDC.SelectObject(pOldFont);
  856.         }
  857.         memDC.SelectObject(pOldMemDCBitmap);
  858. }

  860. void CCreditStatic::OnDestroy()
  861. {
  862.         CStatic::OnDestroy();

  864.         m_ArrCredit.RemoveAll();

  866.         if(TimerOn)
  867.                 ASSERT(KillTimer(DISPLAY_TIMER_ID));       
  868. }

  870. BOOL CCreditStatic::SetBkImage(UINT nIDResource)
  871. {
  872.     return SetBkImage( (LPCTSTR)nIDResource );
  873. }

  875. BOOL CCreditStatic::SetBkImage(LPCTSTR lpszResourceName)
  876. {

  878.     // If this is not the first call then Delete GDI objects
  879.     if( m_bitmap.m_hObject != NULL )
  880.                 m_bitmap.DeleteObject();
  881.     if( m_pal.m_hObject != NULL )
  882.                 m_pal.DeleteObject();
  883.    
  884.    
  885.     HBITMAP hBmp = (HBITMAP)::LoadImage( AfxGetInstanceHandle(),
  886.             lpszResourceName, IMAGE_BITMAP, 0,0, LR_CREATEDIBSECTION );

  888.      if( hBmp == NULL )
  889.         return FALSE;

  891.         m_bitmap.Attach( hBmp );
  892.     BITMAP bm;
  893.     m_bitmap.GetBitmap( &bm );
  894.     m_cxBitmap = bm.bmWidth;
  895.     m_cyBitmap = bm.bmHeight;

  897.     // Create a logical palette for the bitmap
  898.     DIBSECTION ds;
  899.     BITMAPINFOHEADER &bmInfo = ds.dsBmih;
  900.     m_bitmap.GetObject( sizeof(ds), &ds );

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

  904.     // Create a halftone palette if colors > 256.
  905.     CClientDC dc(NULL);             // Desktop DC
  906.     if( nColors > 256 )
  907.         m_pal.CreateHalftonePalette( &dc );
  908.     else
  909.     {
  910.         // Create the palette

  912.         RGBQUAD *pRGB = new RGBQUAD[nColors];
  913.         CDC memDC;
  914.         memDC.CreateCompatibleDC(&dc);

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

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

  922.         pLP->palVersion = 0x300;
  923.         pLP->palNumEntries = nColors;

  925.         for( int i=0; i < nColors; i++)
  926.         {
  927.             pLP->palPalEntry[i].peRed = pRGB[i].rgbRed;
  928.             pLP->palPalEntry[i].peGreen = pRGB[i].rgbGreen;
  929.             pLP->palPalEntry[i].peBlue = pRGB[i].rgbBlue;
  930.             pLP->palPalEntry[i].peFlags = 0;
  931.         }

  933.         m_pal.CreatePalette( pLP );

  935.                 memDC.SelectObject(pOldMemDCBitmap);
  936.         delete[] pLP;
  937.         delete[] pRGB;
  938.     }
  939. //    Invalidate();

  941.     return TRUE;
  942. }
复制代码


相关帖子
回复

使用道具 举报

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