工控编程吧

标题: 上位机MFC滚动文本实例 [打印本页]

---

作者: qq263946146    时间: 2019-7-9 11:30
标题: 上位机MFC滚动文本实例
效果演示
当前程序基于CStatic派生了一个CReditStatic类，用于实现滚动文本。
通常程序都有一个关于对话框，如果将对话框内容设计成滚动效果，
美化程序的同时，也可以将过多的内容以滚动形式展示给用户阅读。
下面是程序效果图：
(, 下载次数: 0)

上传

点击文件名下载附件

实现过程：
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.最后就是编译运行例程，查看效果
下面是文件源代码，可以复制使用，也可以下载例程工程使用：
(, 下载次数: 0)

上传

点击文件名下载附件

1. #if !defined(AFX_CREDITSTATIC_H__4ABD7701_49F5_11D1_9E3C_00A0245800CF__INCLUDED_)
   
2. #define AFX_CREDITSTATIC_H__4ABD7701_49F5_11D1_9E3C_00A0245800CF__INCLUDED_
   
3. 
   
4. #if _MSC_VER >= 1000
   
5. #pragma once
   
6. #endif // _MSC_VER >= 1000
   
7. // CreditStatic.h : header file
   
8. //
   
9. 
   
10. #define DISPLAY_SLOW                0
    
11. #define DISPLAY_MEDIUM                1
    
12. #define DISPLAY_FAST                2
    
13. 
    
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
    
19. 
    
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
    
24. 
    
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   // '^'
    
29. 
    
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
    
35. 
    
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;
    
52. 
    
53.         CBitmap     m_bmpWork;                  // bitmap holder
    
54.         CBitmap                m_BmpMain;                  // bitmap holder
    
55. 
    
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();
    
70. 
    
71. // Attributes
    
72. public:
    
73. 
    
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
    
92. 
    
93. // Implementation
    
94. public:
    
95.         virtual ~CCreditStatic();
    
96. 
    
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);
     
104. 
     
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
     
111. 
     
112.         DECLARE_MESSAGE_MAP()
     
113. };
     
114. 
     
115. /////////////////////////////////////////////////////////////////////////////
     
116. 
     
117. //{{AFX_INSERT_LOCATION}}
     
118. // Microsoft Developer Studio will insert additional declarations immediately before the previous line.
     
119. 
     
120. #endif // !defined(AFX_CREDITSTATIC_H__4ABD7701_49F5_11D1_9E3C_00A0245800CF__INCLUDED_)
     

复制代码

1. #include "stdafx.h"
   
2. #include "CreditStatic.h"
   
3. 
   
4. #ifdef _DEBUG
   
5. #define new DEBUG_NEW
   
6. #undef THIS_FILE
   
7. static char THIS_FILE[] = __FILE__;
   
8. #endif
   
9. 
   
10. #define  DISPLAY_TIMER_ID                150                // timer id
    
11. /////////////////////////////////////////////////////////////////////////////
    
12. // CCreditStatic
    
13. 
    
14. CCreditStatic::CCreditStatic()
    
15. {
    
16. 
    
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
    
22. 
    
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];
    
28. 
    
29. 
    
30.         m_Escapes[0] = '\t';
    
31.         m_Escapes[1] = '\n';
    
32.         m_Escapes[2] = '\r';
    
33.         m_Escapes[3] = '^';
    
34. 
    
35.         m_DisplaySpeed[0] = 70;
    
36.         m_DisplaySpeed[1] = 40;
    
37.         m_DisplaySpeed[2] = 10;
    
38. 
    
39.         m_CurrentSpeed = 1;
    
40.         m_ScrollAmount = -1;
    
41.         m_bProcessingBitmap = FALSE;
    
42. 
    
43.         m_ArrIndex = NULL;
    
44.         m_nCounter = 1;
    
45.         m_nClip = 0;
    
46. 
    
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. }
    
55. 
    
56. CCreditStatic::~CCreditStatic()
    
57. {
    
58. }
    
59. 
    
60. 
    
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()
    
69. 
    
70. /////////////////////////////////////////////////////////////////////////////
    
71. // CCreditStatic message handlers
    
72. 
    
73. BOOL CCreditStatic::StartScrolling()
    
74. {
    
75.         if(m_ArrCredit.IsEmpty())
    
76.                 return FALSE;
    
77. 
    
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);
    
85. 
    
86.         m_ArrIndex = m_ArrCredit.GetHeadPosition();
    
87.         m_nCounter = 1;
    
88.         m_nClip = 0;
    
89. 
    
90.         m_bFirstTime = TRUE;
    
91.         m_bDrawText = FALSE;
    
92. 
    
93.         return TRUE;
    
94. }
    
95. 
    
96. void CCreditStatic::EndScrolling()
    
97. {
    
98.         KillTimer(DISPLAY_TIMER_ID);
    
99.         TimerOn = 0;
    
100. 
     
101.         if(m_BmpMain.m_hObject != NULL) {
     
102.                 m_BmpMain.DeleteObject();
     
103.                 m_BmpMain.m_hObject = NULL;
     
104.         }
     
105. }
     
106. 
     
107. void CCreditStatic::SetCredits(LPCTSTR credits,char delimiter)
     
108. {
     
109.         char *str,*ptr1,*ptr2;
     
110.    
     
111.         ASSERT(credits);
     
112. 
     
113.         if((str = strdup(credits)) == NULL)
     
114.                 return;
     
115. 
     
116.         m_ArrCredit.RemoveAll();
     
117. 
     
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);
     
125. 
     
126.         free(str);
     
127. 
     
128.         m_ArrIndex = m_ArrCredit.GetHeadPosition();
     
129.         m_nCounter = 1;
     
130.         m_nClip = 0;
     
131. 
     
132.         m_bFirstTime = TRUE;
     
133.         m_bDrawText = FALSE;
     
134. }
     
135. 
     
136. void CCreditStatic::SetCredits(UINT nID,char delimiter)
     
137. {
     
138.         CString credits;
     
139.         if(!credits.LoadString(nID))
     
140.                 return;
     
141. 
     
142.         SetCredits((LPCTSTR)credits, delimiter);
     
143. }
     
144. 
     
145. void CCreditStatic::SetSpeed(UINT index, int speed)
     
146. {
     
147.         ASSERT(index <= DISPLAY_FAST);
     
148. 
     
149.         if(speed)
     
150.                 m_DisplaySpeed[index] = speed;
     
151. 
     
152.         m_CurrentSpeed = index;
     
153. }
     
154. 
     
155. void CCreditStatic::SetColor(UINT index, COLORREF col)
     
156. {
     
157.         ASSERT(index <= NORMAL_TEXT_COLOR);
     
158. 
     
159.         m_Colors[index] = col;
     
160. }
     
161. 
     
162. void CCreditStatic::SetTextHeight(UINT index, int height)
     
163. {
     
164.         ASSERT(index <= NORMAL_TEXT_HEIGHT);
     
165. 
     
166.         m_TextHeights[index] = height;
     
167. }
     
168. 
     
169. void CCreditStatic::SetEscape(UINT index, char escape)
     
170. {
     
171.         ASSERT(index <= DISPLAY_BITMAP);
     
172. 
     
173.         m_Escapes[index] = escape;
     
174. }
     
175. 
     
176. void CCreditStatic::SetGradient(UINT value)
     
177. {
     
178.         ASSERT(value <= GRADIENT_LEFT_LIGHT);
     
179. 
     
180.         m_Gradient = value;
     
181. }
     
182. 
     
183. void CCreditStatic::SetTransparent(BOOL bTransparent)
     
184. {
     
185.         m_bTransparent = bTransparent;
     
186. }
     
187. 
     
188. void CCreditStatic::OnPaint()
     
189. {
     
190.         CPaintDC dc(this); // device context for painting
     
191.        
     
192.         if(TimerOn) return;
     
193. 
     
194.         CDC memDC;
     
195.         memDC.CreateCompatibleDC(&dc);
     
196. 
     
197.         CBitmap *pOldMemDCBitmap = NULL;
     
198.         CRect m_ScrollRect;
     
199.         GetClientRect(&m_ScrollRect);
     
200. 
     
201.         if(m_BmpMain.m_hObject == NULL) {
     
202. 
     
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);
     
211. 
     
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. }
     
223. 
     
224. BOOL CCreditStatic::OnEraseBkgnd(CDC* pDC)
     
225. {
     
226.         return TRUE;
     
227.        
     
228. //        return CStatic::OnEraseBkgnd(pDC);
     
229. }
     
230. 
     
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.         }
     
246. 
     
247.         BOOL bCheck = FALSE;
     
248. 
     
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);
     
268. 
     
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;
     
272. 
     
273.         MoveCredit(&dc, m_ScrollRect, m_ClientRect, bCheck);
     
274. 
     
275.         AddBackGround(&dc, m_ScrollRect, m_ClientRect);
     
276. 
     
277.         CStatic::OnTimer(nIDEvent);
     
278. }
     
279. 
     
280. void CCreditStatic::AddBackGround(CDC* pDC, CRect& m_ScrollRect, CRect& m_ClientRect)
     
281. {
     
282.         CDC memDC;
     
283.         memDC.CreateCompatibleDC( pDC );
     
284. 
     
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.         }
     
293. 
     
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 );
     
303. 
     
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;
     
309. 
     
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]);
     
314. 
     
315.         // Create the mask from the memory DC
     
316.         maskDC.BitBlt( 0, 0, m_ClientRect.Width(), m_ClientRect.Height(), &memDC, 0, 0, SRCCOPY );
     
317. 
     
318.         tempDC.SelectObject(pOldTempDCBitmap);
     
319.         pOldTempDCBitmap = tempDC.SelectObject( &m_bitmap );
     
320. 
     
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 );
     
326. 
     
327.         if( pDC->GetDeviceCaps(RASTERCAPS) & RC_PALETTE && m_pal.m_hObject != NULL )
     
328.         {
     
329.                 pDC->SelectPalette( &m_pal, FALSE );
     
330.                 pDC->RealizePalette();
     
331. 
     
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 );
     
339. 
     
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);
     
345. 
     
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);
     
351. 
     
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);
     
355. 
     
356.         // Draw the final image to the screen   
     
357.         pDC->BitBlt( 0, 0, m_ScrollRect.Width(), m_ScrollRect.Height(),
     
358.                                         &imageDC, 0, 0, SRCCOPY );
     
359. 
     
360.         imageDC.SelectObject(pOldImageDCBitmap);
     
361.         maskDC.SelectObject(pOldMaskDCBitmap);
     
362.         tempDC.SelectObject(pOldTempDCBitmap);
     
363.         memDC.SelectObject(pOldMemDCBitmap);
     
364. }
     
365. 
     
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.         }
     
373. 
     
374.         CDC memDC;
     
375.         memDC.CreateCompatibleDC( pDC );
     
376. 
     
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 );
     
383. 
     
384.         CDC maskDC;
     
385.         maskDC.CreateCompatibleDC(pDC);
     
386. 
     
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));
     
392. 
     
393.         // Create the mask from the memory DC
     
394.         maskDC.BitBlt( 0, 0, rBitmap->Width(), rBitmap->Height(), &memDC, 0, 0, SRCCOPY );
     
395. 
     
396. 
     
397.         CDC imageDC;
     
398.         CBitmap bmpImage;
     
399.         imageDC.CreateCompatibleDC( pDC );
     
400.         bmpImage.CreateCompatibleBitmap( pDC, rBitmap->Width(), rBitmap->Height() );
     
401.         CBitmap* pOldImageDCBitmap = imageDC.SelectObject( &bmpImage );
     
402. 
     
403.         imageDC.BitBlt(0, 0, rBitmap->Width(), rBitmap->Height(), pDC, rBitmap->left, rBitmap->top, SRCCOPY);
     
404. 
     
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);
     
410. 
     
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);
     
415. 
     
416.         // Combine the foreground with the background
     
417.     imageDC.BitBlt(0, 0, rBitmap->Width(), rBitmap->Height(), &memDC, 0, 0,SRCPAINT);
     
418. 
     
419.         // Draw the final image to the screen   
     
420.         pDC->BitBlt( rBitmap->left, rBitmap->top, rBitmap->Width(), rBitmap->Height(),
     
421.                                         &imageDC, 0, 0, SRCCOPY );
     
422. 
     
423.         imageDC.SelectObject(pOldImageDCBitmap);
     
424.         maskDC.SelectObject(pOldMaskDCBitmap);
     
425.         memDC.SelectObject(pOldMemDCBitmap);
     
426. }
     
427. 
     
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
     
432. 
     
433.         WORD R = GetRValue(color);
     
434.         WORD G = GetGValue(color);
     
435.         WORD B = GetBValue(color);
     
436. 
     
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.         }
     
448. 
     
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;
     
457. 
     
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. }
     
478. 
     
479. #define SCROLLDC
     
480. 
     
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;
     
490. 
     
491. #ifdef SCROLLDC
     
492.         CRect r1;
     
493. #endif
     
494. 
     
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);
     
504. 
     
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);
     
510. 
     
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 );
     
515. 
     
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.         }
     
529. 
     
530.         m_nClip = m_nClip + abs(m_ScrollAmount);       
     
531.        
     
532. 
     
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;
     
542. 
     
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;
     
604. 
     
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.         }
     
643. 
     
644. #ifndef SCROLLDC
     
645.         CRect r1(m_ScrollRect);
     
646.         r1.top = r1.bottom-abs(m_ScrollAmount);
     
647. #endif
     
648. 
     
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);
     
654. 
     
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.         }
     
695. 
     
696.         if (pOldMemDC2Bitmap != NULL) memDC2.SelectObject(pOldMemDC2Bitmap);
     
697.         if (pOldFont != NULL) memDC.SelectObject(pOldFont);
     
698.         memDC.SelectObject(pOldMemDCBitmap);
     
699. }
     
700. 
     
701. void CCreditStatic::DrawCredit(CDC* pDC, CRect& m_ScrollRect)
     
702. {
     
703.         if(m_BmpMain.m_hObject != NULL) return;
     
704. 
     
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;
     
711. 
     
712.         m_BmpMain.CreateCompatibleBitmap( pDC, m_ScrollRect.Width(), m_ScrollRect.Height() );
     
713.         pOldMemDCBitmap = (CBitmap*)memDC.SelectObject(&m_BmpMain);
     
714. 
     
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);
     
719. 
     
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;
     
741. 
     
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;
     
798. 
     
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.                 }
     
829. 
     
830.                 memDC.SetBkMode(TRANSPARENT);
     
831. 
     
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. }
     
859. 
     
860. void CCreditStatic::OnDestroy()
     
861. {
     
862.         CStatic::OnDestroy();
     
863. 
     
864.         m_ArrCredit.RemoveAll();
     
865. 
     
866.         if(TimerOn)
     
867.                 ASSERT(KillTimer(DISPLAY_TIMER_ID));       
     
868. }
     
869. 
     
870. BOOL CCreditStatic::SetBkImage(UINT nIDResource)
     
871. {
     
872.     return SetBkImage( (LPCTSTR)nIDResource );
     
873. }
     
874. 
     
875. BOOL CCreditStatic::SetBkImage(LPCTSTR lpszResourceName)
     
876. {
     
877. 
     
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 );
     
887. 
     
888.      if( hBmp == NULL )
     
889.         return FALSE;
     
890. 
     
891.         m_bitmap.Attach( hBmp );
     
892.     BITMAP bm;
     
893.     m_bitmap.GetBitmap( &bm );
     
894.     m_cxBitmap = bm.bmWidth;
     
895.     m_cyBitmap = bm.bmHeight;
     
896. 
     
897.     // Create a logical palette for the bitmap
     
898.     DIBSECTION ds;
     
899.     BITMAPINFOHEADER &bmInfo = ds.dsBmih;
     
900.     m_bitmap.GetObject( sizeof(ds), &ds );
     
901. 
     
902.     int nColors = bmInfo.biClrUsed ? bmInfo.biClrUsed : 1 << bmInfo.biBitCount;
     
903. 
     
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
     
911. 
     
912.         RGBQUAD *pRGB = new RGBQUAD[nColors];
     
913.         CDC memDC;
     
914.         memDC.CreateCompatibleDC(&dc);
     
915. 
     
916.         CBitmap* pOldMemDCBitmap = memDC.SelectObject( &m_bitmap );
     
917.         ::GetDIBColorTable( memDC, 0, nColors, pRGB );
     
918. 
     
919.         UINT nSize = sizeof(LOGPALETTE) + (sizeof(PALETTEENTRY) * nColors);
     
920.         LOGPALETTE *pLP = (LOGPALETTE *) new BYTE[nSize];
     
921. 
     
922.         pLP->palVersion = 0x300;
     
923.         pLP->palNumEntries = nColors;
     
924. 
     
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.         }
     
932. 
     
933.         m_pal.CreatePalette( pLP );
     
934. 
     
935.                 memDC.SelectObject(pOldMemDCBitmap);
     
936.         delete[] pLP;
     
937.         delete[] pRGB;
     
938.     }
     
939. //    Invalidate();
     
940. 
     
941.     return TRUE;
     
942. }

复制代码

---

欢迎光临 工控编程吧 (https://www.gkbc8.com/)

Powered by Discuz! X3.4