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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 加密解密 > CA认证 > 查看源码
CreditsCtrl.cpp
资源名称：MiniCA2.rar　[点击查看]
上传用户：dengkfang
上传日期：2008-12-30
资源大小：5233k
文件大小：38k
源码类别：

CA认证

开发平台：

Visual C++

CreditsCtrl.cpp：源码内容
  1. // CreditsCtrl.cpp : implementation file
  2. //
  4. #include "stdafx.h"
  5. #include "CreditsCtrl.h"
  7. #include <afxtempl.h>
  9. #ifdef _DEBUG
  10. #define new DEBUG_NEW
  11. #undef THIS_FILE
  12. static char THIS_FILE[] = __FILE__;
  13. #endif
  15. #define CCREDITCTRL_TIMER1 100
  17. // use transparent BitBlts if supported? ( UNTESTED!! )
  18. //#define CCREDITCTRL_USE_TRANSPARENT_BITBLT
  20. // stuff that _should_ have been defined in some header :-/
  21. #ifndef C1_TRANSPARENT
  22.     #define C1_TRANSPARENT 0x0001
  23. #endif 
  24. #ifndef CAPS1
  25.     #define CAPS1 94
  26. #endif 
  27. #ifndef NEWTRANSPARENT
  28.     #define NEWTRANSPARENT 3
  29. #endif
  31. /////////////////////////////////////////////////////////////////////////////
  32. // CCreditsCtrl
  33. LPCTSTR CCreditsCtrl::m_lpszClassName = NULL;
  35. CCreditsCtrl::CCreditsCtrl()
  36. {
  37. m_nTimerSpeed = 40;
  38. m_nCurBitmapOffset = 0;
  39. m_crInternalTransparentColor = RGB(255,0,255);
  40. m_pBackgroundPaint = CCreditsCtrl::DrawBackground;
  41. m_dwBackgroundPaintLParam = GetSysColor(COLOR_BTNFACE);//(DWORD)m_crBackgroundColor;
  42. m_hLinkCursor = NULL;
  43. m_hDefaultCursor = NULL;
  44. m_bCanScroll = TRUE;
  45. m_bIsScrolling = FALSE;
  46. }
  48. CCreditsCtrl::~CCreditsCtrl()
  49. {
  50. }
  53. BEGIN_MESSAGE_MAP(CCreditsCtrl, CWnd)
  54. //{{AFX_MSG_MAP(CCreditsCtrl)
  55. ON_WM_PAINT()
  56. ON_WM_TIMER()
  57. ON_WM_SIZE()
  58. ON_WM_MOUSEMOVE()
  59. ON_WM_LBUTTONDOWN()
  60. ON_WM_LBUTTONUP()
  61. //}}AFX_MSG_MAP
  62. END_MESSAGE_MAP()
  65. BOOL CCreditsCtrl::Create(DWORD dwExStyle, DWORD dwStyle, const RECT& rect, CWnd* pParentWnd, UINT nID, UINT nDefaultCursorID, UINT nLinkCursorID)
  66. {
  67. m_hDefaultCursor = nDefaultCursorID == 0 ? NULL : AfxGetApp()->LoadCursor(nDefaultCursorID);
  68. if(nLinkCursorID == 0)
  69. SetDefaultLinkCursor();
  70. else
  71. m_hLinkCursor = AfxGetApp()->LoadCursor(nLinkCursorID);
  73. // register window class & create CWnd object
  74. if (m_lpszClassName == NULL)
  75. m_lpszClassName = AfxRegisterWndClass(CS_HREDRAW|CS_VREDRAW);
  77. BOOL bResult = CreateEx(dwExStyle, m_lpszClassName, _T(""), dwStyle,
  78. rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top,
  79. pParentWnd->GetSafeHwnd(), (HMENU)nID, NULL );
  81. // start scrolling
  82. if(bResult)
  83. SetTimer(CCREDITCTRL_TIMER1,m_nTimerSpeed*10,NULL);
  85. return bResult;
  86. }
  88. BOOL CCreditsCtrl::Create(DWORD dwExStyle, DWORD dwStyle, UINT nPlaceholderID, CWnd* pParentWnd, UINT nID, UINT nDefaultCursorID, UINT nLinkCursorID)
  89. {
  90. // get rect from placeholder and call create with the found rect
  91. RECT rect;
  92. pParentWnd->GetDlgItem(nPlaceholderID)->GetWindowRect(&rect);
  93. pParentWnd->ScreenToClient(&rect);
  94. return Create(dwExStyle, dwStyle, rect, pParentWnd, nID, nDefaultCursorID, nLinkCursorID);
  95. }
  97. /////////////////////////////////////////////////////////////////////////////
  98. // CCreditsCtrl message handlers
  100. void CCreditsCtrl::OnPaint() 
  101. {
  102. static BOOL bFirstDraw = TRUE;
  104. CPaintDC dc(this); // device context for painting
  106. // init memory DC
  107. CDC memDC;
  108. memDC.CreateCompatibleDC(&dc);
  109. int nMemDCSave = memDC.SaveDC();
  110. CBitmap memBmp;
  111. memBmp.CreateCompatibleBitmap(&dc,m_rcClient.Width(),m_rcClient.Height());
  112. memDC.SelectObject(&memBmp);
  114. // draw backgorund
  115. if(m_pBackgroundPaint!=NULL)
  116. (*m_pBackgroundPaint)(&memDC,m_rcClient,m_bIsScrolling||bFirstDraw,m_dwBackgroundPaintLParam);
  118. // calculate hot rectagle position and save background at that location
  119. CDC hotBgDC;
  120. CBitmap hotbgBmp,*pOldHBgBmp;
  121. CRect rcHotRect;
  122. if(m_rcHotRect != CRect(0,0,0,0))
  123. {
  124. hotBgDC.CreateCompatibleDC(&memDC);
  125. hotbgBmp.CreateCompatibleBitmap(&memDC,m_rcHotRect.Width(),m_rcHotRect.Height());
  126. pOldHBgBmp = hotBgDC.SelectObject(&hotbgBmp);
  128. if(m_nBitmapHeight <= m_rcClient.bottom)
  129. rcHotRect = m_rcHotRect;
  130. else if(m_nBitmapHeight-m_nCurBitmapOffset+m_rcHotRect.top < m_rcClient.bottom)
  131. rcHotRect.SetRect(m_rcHotRect.left,m_nBitmapHeight-m_nCurBitmapOffset+m_rcHotRect.top,m_rcHotRect.right,m_nBitmapHeight-m_nCurBitmapOffset+m_rcHotRect.bottom);
  132. else
  133. rcHotRect.SetRect(m_rcHotRect.left,m_rcHotRect.top-m_nCurBitmapOffset,m_rcHotRect.right,m_rcHotRect.bottom-m_nCurBitmapOffset);
  135. hotBgDC.BitBlt(0,0,m_rcHotRect.Width(),m_rcHotRect.Height(),&memDC,rcHotRect.left,rcHotRect.top,SRCCOPY);
  136. }
  138. // draw normal bitmap
  139. if(m_nBitmapHeight <= m_rcClient.bottom)
  140. {
  141. CRect rect = m_rcClient;
  142. rect.bottom = m_nBitmapHeight;
  143. DrawTransparentBitmap(&m_bmpNormal,&memDC,m_crInternalTransparentColor,rect,rect);
  144. } else
  145. {
  146. DrawTransparentBitmap(&m_bmpNormal,&memDC,m_crInternalTransparentColor,CRect(0,0,m_rcClient.right,min(m_nBitmapHeight-m_nCurBitmapOffset,m_rcClient.bottom)),CRect(0,m_nCurBitmapOffset,0,0/*the two last values are not taken into account by DrawTransparentBitmap anyway*/));
  147. if(m_nBitmapHeight-m_nCurBitmapOffset < m_rcClient.bottom)
  148. DrawTransparentBitmap(&m_bmpNormal,&memDC,m_crInternalTransparentColor,CRect(0,m_nBitmapHeight-m_nCurBitmapOffset,m_rcClient.right,m_rcClient.bottom),CRect(0,0,0,0/*the two last values are not taken into account by DrawTransparentBitmap anyway*/));
  149. }
  151. // draw hot rect onto generic background
  152. if(m_rcHotRect != CRect(0,0,0,0))
  153. {
  154. memDC.BitBlt(rcHotRect.left,rcHotRect.top,rcHotRect.Width(),rcHotRect.Height(),&hotBgDC,0,0,SRCCOPY);
  155. DrawTransparentBitmap(&m_bmpHot,&memDC,m_crInternalTransparentColor,rcHotRect,m_rcHotRect);
  156. hotBgDC.SelectObject(pOldHBgBmp);
  157. }
  159. // copy memory DC to screen
  160. dc.BitBlt(0,0,m_rcClient.Width(),m_rcClient.Height(),&memDC,0,0,SRCCOPY);
  162. memDC.RestoreDC(nMemDCSave);
  164. if(bFirstDraw)
  165. bFirstDraw = FALSE;
  166. }
  168. CString CCreditsCtrl::SetDataString(LPCTSTR lpszNewString)
  169. {
  170. CString sOldString = m_sData;
  171. m_sData = lpszNewString;
  172. if(IsWindow(m_hWnd))
  173. Initialize();
  174. return sOldString;
  175. }
  177. CString CCreditsCtrl::SetDataString(UINT nStringResourceID)
  178. {
  179. CString sOldString = m_sData;
  180. m_sData.LoadString(nStringResourceID);
  181. if(IsWindow(m_hWnd))
  182. Initialize();
  183. return sOldString;
  184. }
  186. CString CCreditsCtrl::FormatDataString(LPCTSTR lpszFormat, ...)
  187. {
  188. ASSERT(AfxIsValidString(lpszFormat));
  190. CString sOldString = m_sData; // store old string
  192. // let CString do the formatting
  193. va_list argList;
  194. va_start(argList, lpszFormat);
  195. m_sData.FormatV(lpszFormat, argList);
  196. va_end(argList);
  198. if(IsWindow(m_hWnd)) // Initialize bitmaps if we have already been Create()d
  199. Initialize();
  201. return sOldString;
  202. }
  204. CString CCreditsCtrl::FormatDataString(UINT nFormatID, ...)
  205. {
  206. CString strFormat;
  207. VERIFY(strFormat.LoadString(nFormatID) != 0); // load resource string
  209. CString sOldString = m_sData; // store old string
  211. // let CString do the formatting
  212. va_list argList;
  213. va_start(argList, nFormatID);
  214. m_sData.FormatV(strFormat, argList);
  215. va_end(argList);
  217. if(IsWindow(m_hWnd)) // Initialize bitmaps if we have already been Create()d
  218. Initialize();
  220. return sOldString;
  221. }
  223. CString CCreditsCtrl::GetDataString()
  224. {
  225. return m_sData;
  226. }
  228. void CCreditsCtrl::SetDefaultLinkCursor()
  229. {
  230. // following code is taken from Chris Maunders hyperlink control (http://www.codeproject.com) - tnx
  231. if (m_hLinkCursor == NULL) // No cursor handle - load our own
  232. {
  233.         // Get the windows directory
  234. CString strWndDir;
  235. GetWindowsDirectory(strWndDir.GetBuffer(MAX_PATH), MAX_PATH);
  236. strWndDir.ReleaseBuffer();
  238. strWndDir += _T("\winhlp32.exe");
  239. // This retrieves cursor #106 from winhlp32.exe, which is a hand pointer
  240. HMODULE hModule = LoadLibrary(strWndDir);
  241. if (hModule) {
  242. HCURSOR hHandCursor = ::LoadCursor(hModule, MAKEINTRESOURCE(106));
  243. if (hHandCursor)
  244. m_hLinkCursor = CopyCursor(hHandCursor);
  245. }
  246. FreeLibrary(hModule);
  247. }
  248. }
  250. void CCreditsCtrl::OnTimer(UINT nIDEvent) 
  251. {
  252. if(nIDEvent == CCREDITCTRL_TIMER1)
  253. {
  254. if(IsWindowVisible())
  255. {
  256. // increment bitmap offset
  257. if(++m_nCurBitmapOffset > m_nBitmapHeight)
  258. m_nCurBitmapOffset = 1;
  260. // update cursor
  261. CPoint point,pt;
  262. GetCursorPos(&point);
  263. pt = point;
  264. ScreenToClient(&point);
  265. if(m_rcClient.PtInRect(point) && WindowFromPoint(pt)==this)
  266. {
  267. CRect rect;
  268. int n;
  269. if((n = HitTest(point)) != -1)
  270. {
  271. rect = m_HotRects[n];
  272. SetCursor(m_hLinkCursor);
  273. }
  274. else
  275. {
  276. rect = CRect(0,0,0,0);
  277. SetCursor(m_hDefaultCursor);
  278. }
  279. if(rect != m_rcHotRect)
  280. m_rcHotRect = rect;
  281. }
  283. // update window
  284. Invalidate(FALSE);
  285. UpdateWindow();
  287. // set timer
  288. SetTimer(CCREDITCTRL_TIMER1,m_nTimerSpeed,NULL);
  289. }
  290. } else
  291. CWnd::OnTimer(nIDEvent);
  292. }
  294. void CCreditsCtrl::OnSize(UINT nType, int cx, int cy) 
  295. {
  296. CWnd::OnSize(nType, cx, cy);
  298. if(IsWindow(m_hWnd))
  299. GetClientRect(m_rcClient);
  300. Initialize();
  301. }
  303. void CCreditsCtrl::TransparentBlt(CDC *pSrcDC, CDC* pDestDC,COLORREF crTrans,const CRect& rcDest,const CRect& rcSrc)
  304. {
  305. int SaveDestDC = pDestDC->SaveDC();
  306. int SaveSrcDC = pSrcDC->SaveDC();
  308. #ifdef CCREDITCTRL_USE_TRANSPARENT_BITBLT // use transparent BitBlts if supported?
  309. // Only attempt this if device supports functionality. ( untested!! )
  310. if(pDestDC->GetDeviceCaps(CAPS1) & C1_TRANSPARENT)
  311. {
  312. // Special transparency background mode
  313. pDestDC->SetBkMode(NEWTRANSPARENT);
  314. pDestDC->SetBkColor(crTrans);
  315. // Actual blt is a simple source copy; transparency is automatic.
  316. pDestDC->BitBlt(rcDest.left, rcDest.top, rcDest.Width(), rcDest.Height(), pSrcDC, rcSrc.left, rcSrc.top, SRCCOPY);
  317. } else // if driver doesn't support transparent BitBlts, do it the hard way
  318. {
  319. #endif
  320. // initialize memory DC and monochrome mask DC
  321. CDC tmpDC, maskDC;
  322. CBitmap bmpTmp, bmpMask;
  323. int SaveTmpDC, SaveMaskDC;
  324. tmpDC.CreateCompatibleDC(pDestDC);
  325. maskDC.CreateCompatibleDC(pDestDC);
  326. SaveTmpDC = tmpDC.SaveDC();
  327. SaveMaskDC = maskDC.SaveDC();
  328. bmpTmp.CreateCompatibleBitmap(pDestDC,rcDest.Width(),rcDest.Height());
  329. bmpMask.CreateBitmap(rcDest.Width(),rcDest.Height(),1,1,NULL);
  330. tmpDC.SelectObject(&bmpTmp);
  331. maskDC.SelectObject(&bmpMask);
  333. // copy existing data from destination dc to memory dc
  334. tmpDC.BitBlt(0,0,rcDest.Width(),rcDest.Height(),pDestDC,rcDest.left,rcDest.top,SRCCOPY);
  336. // create mask
  337. pSrcDC->SetBkColor(crTrans);
  338. maskDC.BitBlt(0,0,rcDest.Width(),rcDest.Height(),pSrcDC,rcSrc.left,rcSrc.top,SRCCOPY);
  340. // do some BitBlt magic
  341. tmpDC.SetBkColor(RGB(255,255,255));
  342. tmpDC.SetTextColor(RGB(0,0,0));
  343. tmpDC.BitBlt(0,0,rcDest.Width(),rcDest.Height(),pSrcDC,rcSrc.left,rcSrc.top,SRCINVERT);
  344. tmpDC.BitBlt(0,0,rcDest.Width(),rcDest.Height(),&maskDC,0,0,SRCAND);
  345. tmpDC.BitBlt(0,0,rcDest.Width(),rcDest.Height(),pSrcDC,rcSrc.left,rcSrc.top,SRCINVERT);
  347. // copy what we have in our memory DC to the destination DC
  348. pDestDC->BitBlt(rcDest.left,rcDest.top,rcDest.Width(),rcDest.Height(),&tmpDC,0,0,SRCCOPY);
  350. // clean up
  351. tmpDC.RestoreDC(SaveTmpDC);
  352. maskDC.RestoreDC(SaveMaskDC);
  354. #ifdef CCREDITCTRL_USE_TRANSPARENT_BITBLT
  355. }
  356. #endif
  357. pDestDC->RestoreDC(SaveDestDC);
  358. pSrcDC->RestoreDC(SaveSrcDC);
  359. }
  361. void CCreditsCtrl::DrawTransparentBitmap(CBitmap *pBitmap, CDC* pDC,COLORREF crTrans,const CRect& rcDest,const CRect& rcSrc)
  362. {
  363. int SaveImageDC;
  365. // initialize image DC
  366. CDC imageDC;
  367. imageDC.CreateCompatibleDC(pDC);
  368. SaveImageDC = imageDC.SaveDC();
  369. imageDC.SelectObject(pBitmap);
  371. TransparentBlt(&imageDC,pDC,crTrans,rcDest,rcSrc);
  373. // clean up
  374. imageDC.RestoreDC(SaveImageDC);
  375. }
  377. void CCreditsCtrl::Initialize()
  378. {
  379. //// [Initialize] ///////////////////////////////////////
  380. //                                                     //
  381. //  Create bitmaps and calc hot regions from m_sData   //
  382. //                                                     //
  383. /////////////////////////////////////////////////////////
  384. int nMaxHeight = 5000;
  386. // initialize normal and hot DCs
  387. CDC *pDC = GetDC();
  388. CDC normalDC, hotDC;
  389. normalDC.CreateCompatibleDC(pDC);
  390. hotDC.CreateCompatibleDC(pDC);
  391. int nSaveDCNormal = normalDC.SaveDC();
  392. int nSaveDCHot = hotDC.SaveDC();
  394. // initialize bitmaps
  395. if(m_bmpNormal.m_hObject)
  396. m_bmpNormal.DeleteObject();
  397. m_bmpNormal.CreateCompatibleBitmap(pDC,m_rcClient.Width(),nMaxHeight);
  398. if(m_bmpHot.m_hObject)
  399. m_bmpHot.DeleteObject();
  400. m_bmpHot.CreateCompatibleBitmap(pDC,m_rcClient.Width(),nMaxHeight);
  402. // select bitmaps into DCs
  403. normalDC.SelectObject(&m_bmpNormal);
  404. hotDC.SelectObject(&m_bmpHot);
  406. // fill with transparent color
  407. normalDC.FillSolidRect(0,0,m_rcClient.right,nMaxHeight,m_crInternalTransparentColor);
  408. hotDC.FillSolidRect(0,0,m_rcClient.right,nMaxHeight,m_crInternalTransparentColor);
  410. CString sData = m_sData;
  412. // substitute line break tags with newline characters
  413. // sData.Remove('n');
  414. // sData.Replace("<br>","n");
  415. // sData.Replace("<p>","nn");
  417. // make sure we get the last line displayed
  418. sData += 'n';
  420. // variables used for parsing
  421. CList<font_attribs,font_attribs&> font_attribs_tree;
  422. font_attribs fa;
  423. fa.bBold = FALSE;
  424. fa.bItalic = FALSE;
  425. fa.bUnderline = FALSE;
  426. fa.bStrikeout = FALSE;
  427. fa.crBkColor = CLR_NONE;
  428. fa.crColor = RGB(0,0,0);
  429. fa.nSize = 12;
  430. strcpy(fa.szName,"Arial");
  431. font_attribs_tree.AddTail(fa); // default font
  432. CList<general_attribs,general_attribs&> general_attribs_tree;
  433. general_attribs ga;
  434. ga.nAlign = 1;
  435. ga.nVAlign = 1;
  436. ga.nMaxWidth = m_rcClient.Width();
  437. ga.nMaxHeight = nMaxHeight;
  438. general_attribs_tree.AddTail(ga); // default alignment
  439. font_attribs link;
  440. BOOL bInsideTag = FALSE;
  441. CString sCurTagName;
  442. CString sCurElement;
  443. CString sCurOption;
  444. int nCurHPos = 0;
  445. int nCurVPos = 0;
  446. int nCurLineHeight = 0;
  447. CArray<line_rect,line_rect&> arcLineRects; // list containg information about the elements in the current line. used for vertical alignment of these element at line break.
  448. BOOL bIsLineEmpty = TRUE;
  449. BOOL bIsOption = FALSE;
  450. TCHAR cTmp;
  451. COLORREF crHrColor;
  452. int nHrWidth;
  453. int nHrSize;
  454. int nHrAlign;
  455. CString sCurLink;
  456. COLORREF crBitmap;
  457. int nBitmapBorder;
  458. CString sBitmap;
  460. CDC lineDC;
  461. lineDC.CreateCompatibleDC(&normalDC);
  462. CBitmap lineBmp;
  463. lineBmp.CreateCompatibleBitmap(&normalDC,ga.nMaxWidth,ga.nMaxHeight);
  464. CBitmap *pOldBmp = lineDC.SelectObject(&lineBmp);
  466. CDC hover_lineDC;
  467. hover_lineDC.CreateCompatibleDC(&hotDC);
  468. CBitmap hover_lineBmp;
  469. hover_lineBmp.CreateCompatibleBitmap(&hotDC,ga.nMaxWidth,ga.nMaxHeight);
  470. CBitmap *pOldHoverBmp = hover_lineDC.SelectObject(&hover_lineBmp);
  472. // main parsing loop... processing character by character
  473. //  (don't even _try_ to understand what's going on here :)
  474. for(int i = 0; i < sData.GetLength() && i >= 0; i++)
  475. {
  476. if(!bInsideTag)
  477. {
  478. if(sData[i] == '<')
  479. {
  480. if(sCurElement != "")
  481. {
  482. Parse_AppendText(&lineDC,&hover_lineDC,&nCurHPos,&nCurVPos,&nCurLineHeight,&arcLineRects,&general_attribs_tree.GetTail(),&font_attribs_tree.GetTail(),sCurElement, sCurLink, link);
  483. bIsLineEmpty = FALSE;
  484. }
  485. sCurTagName = "";
  486. sCurElement = "";
  487. bInsideTag = TRUE;
  488. continue;
  489. }
  490. if(sData[i] == 'n') // line break
  491. {
  492. if(bIsLineEmpty) // if line is empty add the height of a space with the current font
  493. {
  494. fa = font_attribs_tree.GetTail();
  495. CFont font;
  496. font.CreateFont(-fa.nSize,0,0,0,fa.bBold?FW_BOLD:0,fa.bItalic,fa.bUnderline,fa.bStrikeout,0,OUT_DEFAULT_PRECIS,CLIP_DEFAULT_PRECIS,PROOF_QUALITY,DEFAULT_PITCH|FF_DONTCARE,&fa.szName[0]);
  497. CFont *pOldFont = lineDC.SelectObject(&font);
  498. CRect rect(0,0,ga.nMaxWidth,ga.nMaxHeight);
  499. lineDC.DrawText(" ",rect,DT_CALCRECT);
  500. lineDC.SelectObject(pOldFont);
  501. nCurVPos += rect.Height();
  502. } else
  503. {
  504. if(sCurElement != "")
  505. Parse_AppendText(&lineDC,&hover_lineDC,&nCurHPos,&nCurVPos,&nCurLineHeight,&arcLineRects,&general_attribs_tree.GetTail(),&font_attribs_tree.GetTail(),sCurElement,sCurLink,link);
  506. Parse_VAlignLine(&normalDC,&hotDC,&lineDC,&hover_lineDC,nCurHPos,nCurVPos,nCurLineHeight,&arcLineRects,&general_attribs_tree.GetTail());
  507. nCurVPos += nCurLineHeight;
  508. bIsLineEmpty = TRUE;
  509. }
  510. arcLineRects.RemoveAll();
  511. nCurLineHeight = 0;
  512. nCurHPos = 0;
  513. sCurElement = "";
  514. continue;
  515. }
  516. sCurElement += sData[i];
  517. bIsLineEmpty = FALSE;
  518. } else
  519. {
  520. if(sData[i] == '>')
  521. {
  522. if(sCurTagName == "font") // <font face="s" size="n" style="[-b|b][-i|i][-u|u][-s|s]" color="n,n,n" background="n,n,n">
  523. {
  524. font_attribs_tree.AddTail(fa);
  525. general_attribs_tree.AddTail(ga);
  526. } else if(sCurTagName == "" && sCurElement == "/font") // closing font tag.. revove the last attributes from the lists
  527. {
  528. if(font_attribs_tree.GetCount() > 1)
  529. font_attribs_tree.RemoveTail();
  530. if(general_attribs_tree.GetCount() > 1)
  531. general_attribs_tree.RemoveTail();
  532. } else if(sCurTagName == "" && sCurElement == "hr") // no parameters specified for the hr tag.. use the defaults
  533. {
  534. crHrColor = GetSysColor(COLOR_BTNSHADOW); // default color
  535. nHrWidth = ga.nMaxWidth-100; // default width
  536. nHrSize = 2; // default height
  537. nHrAlign = 1; // center by default
  538. sCurTagName = "hr";
  539. }
  540. if(sCurTagName == "hr") // wrap line is needed and draw rect
  541. {
  542. if(!bIsLineEmpty)
  543. {
  544. Parse_VAlignLine(&normalDC,&hotDC,&lineDC,&hover_lineDC,nCurHPos,nCurVPos,nCurLineHeight,&arcLineRects,&general_attribs_tree.GetTail());
  545. nCurVPos += nCurLineHeight;
  546. bIsLineEmpty = TRUE;
  547. }
  548. arcLineRects.RemoveAll();
  549. nCurLineHeight = 0;
  550. nCurHPos = 0;
  551. CRect rect;
  552. rect.left = nHrAlign == 0 ? 0 : (nHrAlign == 2 ? ga.nMaxWidth-nHrWidth : ga.nMaxWidth/2-nHrWidth/2);
  553. rect.right = rect.left + nHrWidth;
  554. rect.top = nCurVPos + 2;
  555. rect.bottom = rect.top + nHrSize;
  556. normalDC.FillSolidRect(rect,crHrColor);
  557. nCurVPos += 4+nHrSize;
  558. } else if(sCurTagName == "" && sCurElement== "/a" && sCurLink != "") // if we have an ending link tag AND valid link action and link region...
  559. sCurLink = "";
  560. else if(sCurTagName == "img" && sBitmap != "")
  561. {
  562. if(sBitmap[0]=='#') // only resource bitmaps allowed at this time
  563. {
  564. CBitmap bmp;
  565. bmp.LoadBitmap(atoi(sBitmap.Mid(1)));
  566. Parse_AppendBitmap(&lineDC,&hover_lineDC,&nCurHPos,&nCurVPos,&nCurLineHeight,&arcLineRects,&general_attribs_tree.GetTail(),&bmp, crBitmap, nBitmapBorder, sCurLink, link);
  567. bIsLineEmpty = FALSE;
  568. }
  569. crBitmap = CLR_NONE;
  570. nBitmapBorder = 0;
  571. sBitmap = "";
  572. } else if(sCurTagName == "br" || (sCurTagName == "" && sCurElement== "br")) // just substitute with newline character
  573. {
  574. sData.SetAt(i,'n');
  575. i--;
  576. } else if(sCurTagName == "p" || (sCurTagName == "" && sCurElement== "p")) // just substitute with 2 newline characters
  577. {
  578. sData.SetAt(i,'n');
  579. sData.SetAt(i-1,'n');
  580. i-= 2;
  581. }
  582. sCurElement = "";
  583. bInsideTag = FALSE;
  584. continue;
  585. }
  586. if(sData[i] == ' ' && !bIsOption)
  587. {
  588. if(sCurElement != "")
  589. {
  590. if(sCurTagName == "")
  591. {
  592. sCurTagName = sCurElement;
  593. sCurTagName.MakeLower();
  594. if(sCurTagName == "font") // store latest font attributes. these are the ones that are modified by the font tags parameters
  595. {
  596. fa = font_attribs_tree.GetTail();
  597. ga = general_attribs_tree.GetTail();
  598. } else if(sCurTagName == "hr") // set default hr options...
  599. {
  600. crHrColor = GetSysColor(COLOR_BTNSHADOW);
  601. nHrWidth = ga.nMaxWidth-10;
  602. nHrSize = 2;
  603. nHrAlign = 1;
  604. } else if(sCurTagName == "a") // init link hot attributes
  605. {
  606. link = font_attribs_tree.GetTail();
  607. link.crColor = 0xeeffffff;
  608. link.crBkColor = 0xeeffffff;
  609. link.bBold = -10;
  610. link.bItalic = -10;
  611. link.bUnderline = -10;
  612. link.bStrikeout = -10;
  613. link.nSize = 0;
  614. link.szName[0] = '';
  615. } else if(sCurTagName == "img")
  616. {
  617. nBitmapBorder = 2;
  618. crBitmap = CLR_NONE;
  619. sBitmap = "";
  620. }
  621. } else
  622. {
  623. sCurOption = sCurTagName;
  624. sCurOption.MakeLower();
  625. }
  626. }
  627. sCurElement = "";
  628. continue;
  629. }
  630. if(sData[i] == '"' || sData[i] == ''') // this happens when we have a new parameter value to parse
  631. {
  632. if(bIsOption && sData[i]==cTmp) // "sData[i]==cTmp" : closing (double)quote has to match opening quote
  633. {
  634. if(sCurTagName == "font") // parse font tag paramaters
  635. {
  636. if(sCurOption == "size") // font size
  637. {
  638. int nSize = atoi(sCurElement);
  639. if(nSize > 0 && nSize < 2000) // let's be reasonable
  640. fa.nSize = nSize;
  641. } else if(sCurOption == "face") // font face
  642. {
  643. strcpy(fa.szName,sCurElement.Left(MAX_PATH-1));
  644. } else if(sCurOption == "style") // font style (bold (b) ,italic (i) ,underline (u) ,strikeout (s) )
  645. {
  646. if(sCurElement.Find("-b")!=-1 || sCurElement.Find("-B")!=-1)
  647. fa.bBold = FALSE;
  648. else if(sCurElement.FindOneOf("bB")!=-1)
  649. fa.bBold = TRUE;
  650. if(sCurElement.Find("-i")!=-1 || sCurElement.Find("-I")!=-1)
  651. fa.bItalic = FALSE;
  652. else if(sCurElement.FindOneOf("iI")!=-1)
  653. fa.bItalic = TRUE;
  654. if(sCurElement.Find("-u")!=-1 || sCurElement.Find("-U")!=-1)
  655. fa.bUnderline = FALSE;
  656. else if(sCurElement.FindOneOf("uU")!=-1)
  657. fa.bUnderline = TRUE;
  658. if(sCurElement.Find("-s")!=-1 || sCurElement.Find("-S")!=-1)
  659. fa.bStrikeout = FALSE;
  660. else if(sCurElement.FindOneOf("sS")!=-1)
  661. fa.bStrikeout = TRUE;
  662. } else if(sCurOption == "color") // font color
  663. StringToColor(sCurElement,fa.crColor);
  664. else if(sCurOption == "background") // font background-color
  665. StringToColor(sCurElement,fa.crBkColor);
  666. else if(sCurOption == "align") // horisontal font alignment. here we change the "general_attribs"
  667. { // only the latest open font tag with this parameter takes effect at a line break!!
  668. sCurElement.MakeLower();
  669. if(sCurElement == "left")
  670. ga.nAlign = 0;
  671. else if(sCurElement == "center")
  672. ga.nAlign = 1;
  673. else if(sCurElement == "right")
  674. ga.nAlign = 2;
  675. } else if(sCurOption == "valign") // vertical font alignment. here we change the "general_attribs"
  676. {
  677. sCurElement.MakeLower();
  678. if(sCurElement == "top")
  679. ga.nVAlign = 0;
  680. else if(sCurElement == "middle")
  681. ga.nVAlign = 1;
  682. else if(sCurElement == "bottom")
  683. ga.nVAlign = 2;
  684. }
  685. } else if(sCurTagName == "a")
  686. {
  687. if(sCurOption == "href") // what to do
  688. sCurLink = sCurElement;
  689. else if(sCurOption == "size") // font size
  690. {
  691. int nSize = atoi(sCurElement);
  692. if(nSize > 0 && nSize < 2000) // let's be reasonable
  693. link.nSize = nSize;
  694. } else if(sCurOption == "face") // font face
  695. {
  696. strcpy(link.szName,sCurElement.Left(MAX_PATH-1));
  697. } else if(sCurOption == "style") // font style (bold (b) ,italic (i) ,underline (u) ,strikeout (s) )
  698. {
  699. if(sCurElement.Find("-b")!=-1 || sCurElement.Find("-B")!=-1)
  700. link.bBold = FALSE;
  701. else if(sCurElement.FindOneOf("bB")!=-1)
  702. link.bBold = TRUE;
  703. if(sCurElement.Find("-i")!=-1 || sCurElement.Find("-I")!=-1)
  704. link.bItalic = FALSE;
  705. else if(sCurElement.FindOneOf("iI")!=-1)
  706. link.bItalic = TRUE;
  707. if(sCurElement.Find("-u")!=-1 || sCurElement.Find("-U")!=-1)
  708. link.bUnderline = FALSE;
  709. else if(sCurElement.FindOneOf("uU")!=-1)
  710. link.bUnderline = TRUE;
  711. if(sCurElement.Find("-s")!=-1 || sCurElement.Find("-S")!=-1)
  712. link.bStrikeout = FALSE;
  713. else if(sCurElement.FindOneOf("sS")!=-1)
  714. link.bStrikeout = TRUE;
  715. } else if(sCurOption == "color") // font color
  716. StringToColor(sCurElement,link.crColor);
  717. else if(sCurOption == "background") // font background-color
  718. StringToColor(sCurElement,link.crBkColor);
  719. } else if(sCurTagName == "img") // image tag: <img src="#resourceID">
  720. {
  721. // TODO: alow usage of filenames in <img> tag
  722. if(sCurOption == "src" && sCurElement != "")
  723. sBitmap = sCurElement;
  724. if(sCurOption == "color")
  725. StringToColor(sCurElement,crBitmap);
  726. if(sCurOption == "border" && sCurElement != "")
  727. nBitmapBorder = atoi(sCurElement);
  728. } else if(sCurTagName == "hr") // horisontal ruler
  729. {
  730. if(sCurElement != "")
  731. {
  732. if(sCurOption == "color") // color
  733. StringToColor(sCurElement,crHrColor);
  734. else if(sCurOption == "width") // width
  735. nHrWidth = atoi(sCurElement);
  736. else if(sCurOption == "size") // height
  737. nHrSize = atoi(sCurElement);
  738. else if(sCurOption == "align") // horz alignment
  739. {
  740. sCurElement.MakeLower();
  741. if(sCurElement=="left")
  742. nHrAlign = 0;
  743. else if(sCurElement=="right")
  744. nHrAlign = 2;
  745. else
  746. nHrAlign = 1;
  747. }
  748. }
  749. } else if((sCurTagName == "vspace") && (sCurOption == "size")) // vertical space
  750. {
  751. if(!bIsLineEmpty) // insert linebreak only is line isn't empty
  752. {
  753. Parse_VAlignLine(&normalDC,&hotDC,&lineDC,&hover_lineDC,nCurHPos,nCurVPos,nCurLineHeight,&arcLineRects,&general_attribs_tree.GetTail());
  754. nCurVPos += nCurLineHeight;
  755. bIsLineEmpty = TRUE;
  756. }
  757. arcLineRects.RemoveAll();
  758. nCurLineHeight = 0;
  759. nCurHPos = 0;
  760. nCurVPos += atoi(sCurElement); // add "size" parameters value to vertical offset
  761. } else if((sCurTagName == "hspace") && (sCurOption == "size")) // horisontal space
  762. nCurHPos += atoi(sCurElement); // add "size" parameters value to horisontal offset
  763. sCurElement = "";
  764. bIsOption = FALSE;
  765. } else if(sData[i-1] == '=') // parameter is beginning
  766. {
  767. sCurOption = sCurElement;
  768. sCurOption = sCurOption.Left(sCurOption.GetLength()-1); // remove trailing "=";
  769. sCurOption.MakeLower();
  770. sCurOption.TrimRight();
  771. sCurElement = "";
  772. cTmp = sData[i];
  773. bIsOption = TRUE;
  774. }
  775. continue;
  776. }
  777. sCurElement += sData[i]; // append non-formatting-significant character to curent element
  778. }
  780. }
  781. lineDC.SelectObject(pOldBmp);
  782. hover_lineDC.SelectObject(pOldHoverBmp);
  783. //... finished parsing
  785. m_nBitmapHeight = nCurVPos;
  787. // clean up
  788. normalDC.RestoreDC(nSaveDCNormal);
  789. hotDC.RestoreDC(nSaveDCHot);
  790. }
  792. void CCreditsCtrl::DrawBackground(CDC *pDC, RECT rect, BOOL bAnimate, DWORD lParam)
  793. {
  794. pDC->FillSolidRect(&rect,(COLORREF)lParam);
  795. }
  797. void CCreditsCtrl::SetDefaultBkColor(COLORREF crColor)
  798. {
  799. m_dwBackgroundPaintLParam = (DWORD)crColor; // default background color
  800. }
  802. void CCreditsCtrl::Parse_AppendText(CDC *pDC, CDC *pHoverDC, int *pnCurHPos, int *pnCurVPos, int *pnCurHeight, CArray<line_rect,line_rect&>* parcLineRects, general_attribs *pga, font_attribs *pfa, CString sText, CString sCurLink, font_attribs link)
  803. {
  804. CRect rect(0,0,pga->nMaxWidth,pga->nMaxHeight);
  805. CDC dc,hoverDC;
  806. CBitmap hoverBmp,bmp,*pOldHBmp;
  807. dc.CreateCompatibleDC(pDC);
  809. CFont font,hover_font,*pOldHFont;
  810. font.CreateFont(-pfa->nSize,0,0,0,pfa->bBold?FW_BOLD:0,pfa->bItalic,pfa->bUnderline,pfa->bStrikeout,0,OUT_DEFAULT_PRECIS,CLIP_DEFAULT_PRECIS,PROOF_QUALITY,DEFAULT_PITCH|FF_DONTCARE,pfa->szName);
  811. CFont *pOldFont = dc.SelectObject(&font);
  812. dc.SetTextColor(pfa->crColor == CLR_NONE ? m_crInternalTransparentColor : pfa->crColor);
  813. dc.SetBkColor(pfa->crBkColor == CLR_NONE ? m_crInternalTransparentColor : pfa->crBkColor);
  814. dc.SetBkMode(OPAQUE);
  816. dc.DrawText(sText,rect,DT_CALCRECT|DT_SINGLELINE);
  818. if(sCurLink != "")
  819. {
  820. if(link.bBold == -10) link.bBold = pfa->bBold;
  821. if(link.bItalic == -10) link.bItalic = pfa->bItalic;
  822. if(link.bUnderline == -10) link.bUnderline = pfa->bUnderline;
  823. if(link.bStrikeout == -10) link.bStrikeout = pfa->bStrikeout;
  824. if(link.crColor == 0xeeffffff) link.crColor = pfa->crColor;
  825. if(link.crBkColor == 0xeeffffff) link.crBkColor = pfa->crBkColor;
  826. if(link.nSize == 0) link.nSize = pfa->nSize;
  827. if(link.szName[0] == '') strcpy(link.szName,pfa->szName);
  829. CRect rect2(0,0,pga->nMaxWidth,pga->nMaxHeight);
  831. hoverDC.CreateCompatibleDC(pDC);
  833. hover_font.CreateFont(-link.nSize,0,0,0,link.bBold?FW_BOLD:0,link.bItalic,link.bUnderline,link.bStrikeout,0,OUT_DEFAULT_PRECIS,CLIP_DEFAULT_PRECIS,PROOF_QUALITY,DEFAULT_PITCH|FF_DONTCARE,link.szName);
  834. pOldHFont = hoverDC.SelectObject(&hover_font);
  836. hoverDC.DrawText(sText,rect2,DT_CALCRECT|DT_SINGLELINE);
  838. if(rect.Width() < rect2.Width())
  839. rect = rect2;
  841. hoverBmp.CreateCompatibleBitmap(pDC,rect.right,rect.bottom);
  842. pOldHBmp = hoverDC.SelectObject(&hoverBmp);
  844. hoverDC.FillSolidRect(rect,m_crInternalTransparentColor);
  845. hoverDC.SetTextColor(link.crColor == CLR_NONE ? m_crInternalTransparentColor : link.crColor);
  846. hoverDC.SetBkColor(link.crBkColor == CLR_NONE ? m_crInternalTransparentColor : link.crBkColor);
  847. hoverDC.SetBkMode(OPAQUE);
  849. hoverDC.DrawText(sText,rect,DT_SINGLELINE);
  850. }
  852. bmp.CreateCompatibleBitmap(pDC,rect.right,rect.bottom);
  853. CBitmap *pOldBmp = dc.SelectObject(&bmp);
  855. dc.FillSolidRect(rect,m_crInternalTransparentColor);
  856. dc.SetBkColor(pfa->crBkColor == CLR_NONE ? m_crInternalTransparentColor : pfa->crBkColor);
  857. dc.DrawText(sText,rect,DT_SINGLELINE);
  859. if(sCurLink != "")
  860. {
  861. Parse_AppendElement(pDC,pHoverDC,pnCurHPos,pnCurVPos,pnCurHeight,parcLineRects,pga,rect.Width(),rect.Height(),&dc,&hoverDC,sCurLink);
  862. hoverDC.SelectObject(pOldHBmp);
  863. hoverDC.SelectObject(pOldHFont);
  864. }
  865. else
  866. Parse_AppendElement(pDC,pHoverDC,pnCurHPos,pnCurVPos,pnCurHeight,parcLineRects,pga,rect.Width(),rect.Height(),&dc,&dc,sCurLink);
  868. // clean up
  869. dc.SelectObject(pOldBmp);
  870. dc.SelectObject(pOldFont);
  871. }
  873. void CCreditsCtrl::Parse_AppendBitmap(CDC *pDC, CDC *pHoverDC, int *pnCurHPos, int *pnCurVPos, int *pnCurHeight, CArray<line_rect,line_rect&>* parcLineRects, general_attribs *pga, CBitmap *pBitmap, COLORREF crBorder, int nBorder, CString sCurLink, font_attribs link)
  874. {
  875. BITMAP bm;
  876. pBitmap->GetBitmap(&bm);
  878. CDC bmpDC;
  879. bmpDC.CreateCompatibleDC(pDC);
  880. CBitmap *pOldBmp1 = bmpDC.SelectObject(pBitmap);
  882. CDC dc;
  883. dc.CreateCompatibleDC(pDC);
  884. CBitmap bmp;
  885. bmp.CreateCompatibleBitmap(pDC,bm.bmWidth+nBorder*2,bm.bmHeight+nBorder*2);
  886. CBitmap *pOldBmp2 = dc.SelectObject(&bmp);
  887. dc.FillSolidRect(0,0,bm.bmWidth+nBorder*2,bm.bmHeight+nBorder*2,crBorder==CLR_NONE?m_crInternalTransparentColor:crBorder);
  888. dc.BitBlt(nBorder,nBorder,bm.bmWidth,bm.bmHeight,&bmpDC,0,0,SRCCOPY);
  890. if(sCurLink == "")
  891. Parse_AppendElement(pDC,pHoverDC,pnCurHPos,pnCurVPos,pnCurHeight,parcLineRects,pga,bm.bmWidth+nBorder*2,bm.bmHeight+nBorder*2,&dc,&dc,sCurLink);
  892. else
  893. {
  894. CDC hoverDC;
  895. hoverDC.CreateCompatibleDC(pDC);
  896. CBitmap bmp;
  897. bmp.CreateCompatibleBitmap(pDC,bm.bmWidth+nBorder*2,bm.bmHeight+nBorder*2);
  898. CBitmap *pOldBmp = hoverDC.SelectObject(&bmp);
  899. hoverDC.FillSolidRect(0,0,bm.bmWidth+nBorder*2,bm.bmHeight+nBorder*2,link.crColor==CLR_NONE?m_crInternalTransparentColor:link.crColor==0xeeffffff?crBorder:link.crColor);
  900. hoverDC.BitBlt(nBorder,nBorder,bm.bmWidth,bm.bmHeight,&bmpDC,0,0,SRCCOPY);
  901. Parse_AppendElement(pDC,pHoverDC,pnCurHPos,pnCurVPos,pnCurHeight,parcLineRects,pga,bm.bmWidth+nBorder*2,bm.bmHeight+nBorder*2,&dc,&hoverDC,sCurLink);
  902. hoverDC.SelectObject(pOldBmp);
  903. }
  905. // clean up
  906. dc.SelectObject(pOldBmp2);
  907. bmpDC.SelectObject(pOldBmp1);
  908. }
  910. void CCreditsCtrl::Parse_AppendElement(CDC *pDC, CDC *pHoverDC, int *pnCurHPos, int *pnCurVPos, int *pnCurHeight, CArray<line_rect,line_rect&>* parcLineRects, general_attribs *pga, int nElementWidth, int nElementHeight, CDC *pElementDC, CDC *pHoverElementDC, CString sCurLink)
  911. {
  912. if(*pnCurHeight < nElementHeight)
  913. *pnCurHeight = nElementHeight;
  915. CRect rect;
  916. rect.left = *pnCurHPos;
  917. rect.top = 0;
  918. rect.right = rect.left+nElementWidth;
  919. rect.bottom = nElementHeight;
  921. line_rect lr;
  922. lr.rcRect = rect;
  923. lr.nVAlign = pga->nVAlign;
  924. lr.sLink = sCurLink;
  925. parcLineRects->Add(lr);
  927. pDC->BitBlt(rect.left,rect.top,rect.Width(),rect.Height(),pElementDC,0,0,SRCCOPY);
  928. pHoverDC->BitBlt(rect.left,rect.top,rect.Width(),rect.Height(),pHoverElementDC,0,0,SRCCOPY);
  929. *pnCurHPos += nElementWidth;
  930. }
  932. void CCreditsCtrl::Parse_VAlignLine(CDC *pDestDC, CDC *pHoverDestDC, CDC *pLineDC, CDC *pHoverLineDC, int nCurHPos, int nCurVPos, int nCurHeight, CArray<line_rect,line_rect&>* parcLineRects, general_attribs *pga)
  933. {
  934. {
  935. CArray<line_rect,line_rect&> LinkElements;
  937. CRect rect;
  938. CDC memDC;
  939. memDC.CreateCompatibleDC(pDestDC);
  940. CBitmap memBmp;
  941. memBmp.CreateCompatibleBitmap(pDestDC,nCurHPos,nCurHeight);
  942. CBitmap *pOldBmp = memDC.SelectObject(&memBmp);
  943. memDC.FillSolidRect(0,0,nCurHPos,nCurHeight,m_crInternalTransparentColor);
  944. for(int i = 0; i < parcLineRects->GetSize(); i++)
  945. {
  946. rect.left = (*parcLineRects)[i].rcRect.left;
  947. // calculate elements vertical position
  948. if((*parcLineRects)[i].nVAlign == 0) // top align
  949. rect.top = 0;
  950. else if((*parcLineRects)[i].nVAlign == 1) // middle align
  951. rect.top = nCurHeight/2-(*parcLineRects)[i].rcRect.bottom/2;
  952. else // bottom align
  953. rect.top = nCurHeight - (*parcLineRects)[i].rcRect.bottom;
  954. rect.bottom = rect.top + (*parcLineRects)[i].rcRect.bottom;
  955. // don't touch horz alignment
  956. rect.left = (*parcLineRects)[i].rcRect.left;
  957. rect.right = (*parcLineRects)[i].rcRect.right;
  959. // draw element
  960. memDC.BitBlt(rect.left,rect.top,rect.Width(),rect.Height(),pLineDC,(*parcLineRects)[i].rcRect.left,(*parcLineRects)[i].rcRect.top,SRCCOPY);
  962. // add link to list(if necessary)
  963. if((*parcLineRects)[i].sLink != "")
  964. {
  965. line_rect lr;
  966. lr.sLink = (*parcLineRects)[i].sLink;
  967. lr.rcRect = rect;
  968. LinkElements.Add(lr);
  969. }
  970. }
  972. rect.top = nCurVPos;
  973. rect.bottom = rect.top + nCurHeight;
  974. if(pga->nAlign == 0) // left align
  975. rect.left = 0;
  976. else if(pga->nAlign == 1) // center align
  977. rect.left = pga->nMaxWidth/2 - nCurHPos/2;
  978. else // right align
  979. rect.left = pga->nMaxWidth - nCurHPos;
  980. rect.right = rect.left + nCurHPos;
  982. TransparentBlt(&memDC,pDestDC,m_crInternalTransparentColor,rect,CRect(0,0,rect.Width(),rect.Height()));
  983. memDC.SelectObject(pOldBmp);
  985. // calculate horisontal offset of links in list and add them to global list
  986. for(i = 0; i < LinkElements.GetSize(); i++)
  987. {
  988. CRect rc = LinkElements[i].rcRect;
  989. rc.OffsetRect(rect.left,nCurVPos);
  990. m_HotRects.Add(rc);
  991. m_HotRectActions.Add(LinkElements[i].sLink);
  992. }
  993. }
  995. // do the same, but this time for the hover CD
  996. {
  997. CRect rect;
  998. CDC memDC;
  999. memDC.CreateCompatibleDC(pHoverDestDC);
  1000. CBitmap memBmp;
  1001. memBmp.CreateCompatibleBitmap(pHoverDestDC,nCurHPos,nCurHeight);
  1002. CBitmap *pOldBmp = memDC.SelectObject(&memBmp);
  1003. memDC.FillSolidRect(0,0,nCurHPos,nCurHeight,m_crInternalTransparentColor);
  1004. for(int i = 0; i < parcLineRects->GetSize(); i++)
  1005. {
  1006. rect.left = (*parcLineRects)[i].rcRect.left;
  1007. // calculate elements vertical position
  1008. if((*parcLineRects)[i].nVAlign == 0) // top align
  1009. rect.top = 0;
  1010. else if((*parcLineRects)[i].nVAlign == 1) // middle align
  1011. rect.top = nCurHeight/2-(*parcLineRects)[i].rcRect.bottom/2;
  1012. else // bottom align
  1013. rect.top = nCurHeight - (*parcLineRects)[i].rcRect.bottom;
  1014. rect.bottom = rect.top + (*parcLineRects)[i].rcRect.bottom;
  1015. // don't touch horz alignment
  1016. rect.left = (*parcLineRects)[i].rcRect.left;
  1017. rect.right = (*parcLineRects)[i].rcRect.right;
  1019. // draw element
  1020. memDC.BitBlt(rect.left,rect.top,rect.Width(),rect.Height(),pHoverLineDC,(*parcLineRects)[i].rcRect.left,(*parcLineRects)[i].rcRect.top,SRCCOPY);
  1021. }
  1023. rect.top = nCurVPos;
  1024. rect.bottom = rect.top + nCurHeight;
  1025. if(pga->nAlign == 0) // left align
  1026. rect.left = 0;
  1027. else if(pga->nAlign == 1) // center align
  1028. rect.left = pga->nMaxWidth/2 - nCurHPos/2;
  1029. else // right align
  1030. rect.left = pga->nMaxWidth - nCurHPos;
  1031. rect.right = rect.left + nCurHPos;
  1033. TransparentBlt(&memDC,pHoverDestDC,m_crInternalTransparentColor,rect,CRect(0,0,rect.Width(),rect.Height()));
  1034. memDC.SelectObject(pOldBmp);
  1035. }
  1036. }
  1038. BOOL CCreditsCtrl::StringToColor(CString string, COLORREF &cr)
  1039. {
  1040. int i,r,g,b;
  1041. if(string=="")
  1042. return FALSE;
  1043. else if((string=="none")||(string=="transparant"))
  1044. cr = CLR_NONE;
  1045. else if((i = string.Find(','))==-1)
  1046. return FALSE;
  1047. else
  1048. {
  1049. r = atoi(string.Left(i));
  1050. string.Delete(0,i+1);
  1051. if((i = string.Find(','))==-1)
  1052. return FALSE;
  1053. else
  1054. {
  1055. g = atoi(string.Left(i));
  1056. string.Delete(0,i+1);
  1057. b = atoi(string);
  1058. cr = RGB(r,g,b);
  1059. }
  1060. }
  1061. return TRUE;
  1062. }
  1064. void CCreditsCtrl::OnMouseMove(UINT nFlags, CPoint point) 
  1065. {
  1066. if(m_bIsScrolling)
  1067. {
  1068. m_nCurBitmapOffset = m_nScrollStart-point.y;
  1069. m_nCurBitmapOffset %= m_nBitmapHeight;
  1070. if(m_nCurBitmapOffset < 0)
  1071. m_nCurBitmapOffset = m_nCurBitmapOffset+m_nBitmapHeight;
  1072. Invalidate(FALSE);
  1073. UpdateWindow();
  1074. return;
  1075. }
  1076. if(GetCapture()==this)
  1077. ReleaseCapture();
  1078. else
  1079. SetCapture();
  1081. if(m_rcClient.PtInRect(point))
  1082. {
  1083. int n;
  1084. CRect rect;
  1085. if((n = HitTest(point)) != -1)
  1086. {
  1087. rect = m_HotRects[n];
  1088. SetCursor(m_hLinkCursor);
  1089. }
  1090. else
  1091. {
  1092. rect = CRect(0,0,0,0);
  1093. SetCursor(m_hDefaultCursor);
  1094. }
  1095. if(rect != m_rcHotRect)
  1096. {
  1097. m_rcHotRect = rect;
  1098. // Invalidate(FALSE);
  1099. // UpdateWindow();
  1100. }
  1101. }
  1102. }
  1104. void CCreditsCtrl::OnLButtonDown(UINT nFlags, CPoint point) 
  1105. {
  1106. int n = HitTest(point);
  1107. if(n != -1)
  1108. {
  1109. m_rcHotRect = CRect(0,0,0,0); // will be update next timer tick
  1110. CString s = m_HotRectActions[n];
  1111. if(s[0] == '#')
  1112. {
  1113. int i = s.Find('#',1);
  1114. CString arg = i==-1?"":s.Mid(1,i-1);
  1115. s = s.Mid(i==-1?1:i+1);
  1116. void(*func)(LPCTSTR) = (void(*)(LPCTSTR))atol(s);
  1117. if(func)
  1118. (*func)(i==-1?NULL:(LPCTSTR)arg);
  1119. } else
  1120. ShellExecute(NULL,NULL,s,NULL,NULL,SW_SHOW);
  1121. } else if(m_bCanScroll && (m_nBitmapHeight > m_rcClient.bottom))
  1122. {
  1123. KillTimer(CCREDITCTRL_TIMER1);
  1124. m_bIsScrolling = TRUE;
  1125. m_nScrollStart = point.y + m_nCurBitmapOffset;
  1126. Invalidate();
  1127. UpdateWindow();
  1128. SetCapture();
  1129. }
  1130. }
  1132. void CCreditsCtrl::OnLButtonUp(UINT nFlags, CPoint point) 
  1133. {
  1134. if(m_bIsScrolling)
  1135. {
  1136. ReleaseCapture();
  1137. m_bIsScrolling = FALSE;
  1138. OnTimer(CCREDITCTRL_TIMER1);
  1139. }
  1140. }
  1142. int CCreditsCtrl::HitTest(CPoint pt)
  1143. {
  1144. if(m_nBitmapHeight <= m_rcClient.bottom)
  1145. {
  1146. for(int i = 0; i < m_HotRects.GetSize(); i++)
  1147. {
  1148. if(m_HotRects[i].PtInRect(pt))
  1149. return i;
  1150. }
  1151. return -1;
  1152. }
  1154. pt.y += m_nCurBitmapOffset;
  1155. CPoint pt0 = pt;
  1156. if(pt0.y > m_nBitmapHeight-m_nCurBitmapOffset)
  1157. pt0.y -= m_nBitmapHeight;
  1159. for(int i = 0; i < m_HotRects.GetSize(); i++)
  1160. {
  1161. if(m_HotRects[i].PtInRect(pt) || m_HotRects[i].PtInRect(pt0))
  1162. return i;
  1163. }
  1164. return -1;
  1165. }