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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多国语言处理 > 查看源码
WELCOME.CPP
资源名称：ChineseScape.zip　[点击查看]
上传用户：zhang8947
上传日期：2007-01-08
资源大小：1910k
文件大小：15k
源码类别：

多国语言处理

开发平台：

Visual C++

WELCOME.CPP：源码内容
  1. #include "stdafx.h"
  2. #include "welcome.h"
  4. //显示欢迎画面
  5. BOOL WelcomeToYou(CSplashWnd& splashWnd ,LPSTR lpFileName)
  6. {
  7. char szDrive[_MAX_DRIVE],szDir[_MAX_DIR],szTemp[_MAX_FNAME], szFileName[128];
  9. GetModuleFileName(AfxGetApp()->m_hInstance, szFileName, 128);
  10. _splitpath(szFileName, szDrive, szDir, szTemp, szTemp);
  11. wsprintf(szFileName, "%s%s%s", szDrive, szDir, lpFileName);
  12. // CSplashWnd  splashWnd ;
  13. if( !splashWnd.Create( szFileName )){
  14. AfxMessageBox( "Create splash window fail !") ; 
  15. return FALSE ;
  16. }
  17. splashWnd.ShowWindow(SW_SHOW);
  18. splashWnd.UpdateWindow();
  20. return TRUE;
  21. }
  23. //--------------------------------------------------------------------------------------------//
  24. #define IS_WIN30_DIB(lpbi)  ((*(LPDWORD)(lpbi)) == sizeof(BITMAPINFOHEADER))
  25. #define RECTWIDTH(lpRect)     ((lpRect)->right - (lpRect)->left)
  26. #define RECTHEIGHT(lpRect)    ((lpRect)->bottom - (lpRect)->top)
  28. CImageFile::CImageFile()
  29. {
  30. m_hDib  = NULL ;
  31. m_hImageData = NULL ;
  32. m_nKindOfImage = IMAGE_UNKNOWN ;
  33. m_palDIB = NULL ;
  34. m_strFileName = "" ;
  36. }
  38. CImageFile::CImageFile(LPSTR cFileName)
  39. {
  40. m_hDib  = NULL ;
  41. m_hImageData = NULL ;
  42. m_nKindOfImage = IMAGE_UNKNOWN ;
  43. m_palDIB = NULL ;
  44. m_strFileName = cFileName ;
  45. }
  47. CImageFile::~CImageFile()
  48. {
  49. if(m_hDib != NULL )
  50. ::GlobalFree( m_hDib ) ; 
  52. if(m_palDIB)
  53. delete m_palDIB ;
  54. }
  56. BOOL  CImageFile::CreateImage( LPSTR cFileName )
  57. {
  58. m_hDib  = NULL ;
  59. m_hImageData = NULL ;
  60. m_nKindOfImage = IMAGE_UNKNOWN ;
  61. m_palDIB = NULL ;
  62. m_strFileName = cFileName ;                  
  63. return TRUE ;
  64. }
  66. BOOL  CImageFile:: PaintImage(HDC hDC , CRect *lpDCRect) 
  67. {
  68. LPSTR    lpDIBHdr;            // Pointer to BITMAPINFOHEADER
  69. LPSTR    lpDIBBits;           // Pointer to DIB bits
  70. BOOL     bSuccess=FALSE;      // Success/fail flag
  71. HPALETTE hPal=NULL;           // Our DIB's palette
  72. HPALETTE hOldPal=NULL;        // Previous palette
  74. /* Check for valid DIB handle */
  75. if (m_hDib == NULL)
  76. return FALSE;
  77.     
  78. int nDibWidth = ImageWidth()  ;
  79. int nDibHeight = ImageHeight() ;
  80.     
  81. /* Lock down the DIB, and get a pointer to the beginning of the bit
  82.  *  buffer
  83.  */
  84. lpDIBHdr  = (LPSTR) ::GlobalLock((HGLOBAL) m_hDib);
  85. lpDIBBits = (char far*)FindDIBBits(lpDIBHdr);
  87. // Get the DIB's palette, then select it into DC
  88. if (m_palDIB != NULL)
  89. {
  90. hPal = (HPALETTE) (m_palDIB->m_hObject);
  92. // Select as background since we have
  93. // already realized in forground if needed
  94. hOldPal = ::SelectPalette(hDC, hPal, TRUE);
  95. ::RealizePalette( hDC );
  96. }
  98. /* Make sure to use the stretching mode best for color pictures */
  99. ::SetStretchBltMode(hDC, COLORONCOLOR);
  101. /* Determine whether to call StretchDIBits() or SetDIBitsToDevice() */
  102. if ((RECTWIDTH(lpDCRect)  == nDibWidth) &&
  103.    (RECTHEIGHT(lpDCRect) == nDibHeight)) {
  104. bSuccess = ::SetDIBitsToDevice(hDC,                    // hDC
  105.    lpDCRect->left,             // DestX
  106.    lpDCRect->top,              // DestY
  107.    RECTWIDTH(lpDCRect),        // nDestWidth
  108.    RECTHEIGHT(lpDCRect),       // nDestHeight
  109.    0,
  110.    0,
  111.    0,                          // nStartScan
  112.    nDibHeight,   // nNumScans
  113.    lpDIBBits,                  // lpBits
  114.    (LPBITMAPINFO)lpDIBHdr,     // lpBitsInfo
  115.    DIB_RGB_COLORS);            // wUsage
  116.    }
  117.    else{
  118.   bSuccess = ::StretchDIBits(hDC,                          // hDC
  119.    lpDCRect->left,                 // DestX
  120.    lpDCRect->top,                  // DestY
  121.    RECTWIDTH(lpDCRect),            // nDestWidth
  122.    RECTHEIGHT(lpDCRect),           // nDestHeight
  123.    0,
  124.    0,
  125.    nDibWidth,            // wSrcWidth
  126.    nDibHeight ,          // wSrcHeight
  127.    lpDIBBits,                      // lpBits
  128.    (LPBITMAPINFO)lpDIBHdr,         // lpBitsInfo
  129.    DIB_RGB_COLORS,                 // wUsage
  130.    SRCCOPY);                       // dwROP
  131.    }
  132.    ::GlobalUnlock((HGLOBAL) m_hDib);
  134. /* Reselect old palette */
  135. if (hOldPal != NULL)
  136. {
  137. ::SelectPalette(hDC, hOldPal, TRUE);
  138. }
  140.    return bSuccess;
  141. }
  143. BOOL CImageFile::ReadImageFile()
  144. {
  145. return TRUE ;
  146. }
  148. BOOL CImageFile::TranslateImageToDIB()
  149. {
  150. return TRUE ;
  151. }
  153. BOOL CImageFile::CreatePalette(CPalette* pPal)
  154. {
  155. LPLOGPALETTE lpPal;      // pointer to a logical palette
  156. HANDLE hLogPal;          // handle to a logical palette
  157. HPALETTE hPal = NULL;    // handle to a palette
  158. int i;                   // loop index
  159. WORD wNumColors;         // number of colors in color table
  160. LPSTR lpbi;              // pointer to packed-DIB
  161. LPBITMAPINFO lpbmi;      // pointer to BITMAPINFO structure (Win3.0)
  162. LPBITMAPCOREINFO lpbmc;  // pointer to BITMAPCOREINFO structure (old)
  163. BOOL bWinStyleDIB;       // flag which signifies whether this is a Win3.0 DIB
  164. BOOL bResult = FALSE;
  166. /* if handle to DIB is invalid, return FALSE */
  168. if (m_hDib == NULL)
  169.   return FALSE;
  171.    lpbi = (LPSTR) ::GlobalLock((HGLOBAL) m_hDib);
  173.    /* get pointer to BITMAPINFO (Win 3.0) */
  174.    lpbmi = (LPBITMAPINFO)lpbi;
  176.    /* get pointer to BITMAPCOREINFO (old 1.x) */
  177.    lpbmc = (LPBITMAPCOREINFO)lpbi;
  179.    /* get the number of colors in the DIB */
  180. wNumColors = ImageNumColors();
  182.    if (wNumColors != 0)
  183.    {
  184. /* allocate memory block for logical palette */
  185. hLogPal = ::GlobalAlloc(GHND, sizeof(LOGPALETTE)
  186. + sizeof(PALETTEENTRY)
  187. * wNumColors);
  189. /* if not enough memory, clean up and return NULL */
  190. if (hLogPal == 0)
  191. {
  192. ::GlobalUnlock((HGLOBAL) m_hDib);
  193. return FALSE;
  194. }
  196. lpPal = (LPLOGPALETTE) ::GlobalLock((HGLOBAL) hLogPal);
  198. /* set version and number of palette entries */
  199. lpPal->palVersion = PALVERSION;
  200. lpPal->palNumEntries = (WORD)wNumColors;
  202. /* is this a Win 3.0 DIB? */
  203. bWinStyleDIB = IS_WIN30_DIB(lpbi);
  204. for (i = 0; i < (int)wNumColors; i++)
  205. {
  206. if (bWinStyleDIB)
  207. {
  208. lpPal->palPalEntry[i].peRed = lpbmi->bmiColors[i].rgbRed;
  209. lpPal->palPalEntry[i].peGreen = lpbmi->bmiColors[i].rgbGreen;
  210. lpPal->palPalEntry[i].peBlue = lpbmi->bmiColors[i].rgbBlue;
  211. lpPal->palPalEntry[i].peFlags = 0;
  212. }
  213. else
  214. {
  215. lpPal->palPalEntry[i].peRed = lpbmc->bmciColors[i].rgbtRed;
  216. lpPal->palPalEntry[i].peGreen = lpbmc->bmciColors[i].rgbtGreen;
  217. lpPal->palPalEntry[i].peBlue = lpbmc->bmciColors[i].rgbtBlue;
  218. lpPal->palPalEntry[i].peFlags = 0;
  219. }
  220. }
  222. /* create the palette and get handle to it */
  223. bResult = pPal->CreatePalette(lpPal);
  224. ::GlobalUnlock((HGLOBAL) hLogPal);
  225. ::GlobalFree((HGLOBAL) hLogPal);
  226. }
  228. ::GlobalUnlock((HGLOBAL) m_hDib);
  230. return bResult;
  231. }
  233. void far* CImageFile::FindDIBBits(LPSTR lpbi)
  234. {
  235. return (lpbi + *(LPDWORD)lpbi + PaletteSize());
  236. }
  238. int  CImageFile::ImageWidth()
  239. {
  241. ASSERT( m_hDib != NULL) ;
  243. char far* lpDIB =(char far*)::GlobalLock( m_hDib ) ;
  244. LPBITMAPINFOHEADER lpbmi;  // pointer to a Win 3.0-style DIB
  245. LPBITMAPCOREHEADER lpbmc;  // pointer to an other-style DIB
  247. /* point to the header (whether Win 3.0 and old) */
  249. lpbmi = (LPBITMAPINFOHEADER)lpDIB;
  250. lpbmc = (LPBITMAPCOREHEADER)lpDIB;
  252. long nWidth ;
  253. /* return the DIB width if it is a Win 3.0 DIB */
  254. if (IS_WIN30_DIB(lpDIB))
  255. nWidth = lpbmi->biWidth;
  256. else  /* it is an other-style DIB, so return its width */
  257. nWidth = (DWORD)lpbmc->bcWidth;
  259. ::GlobalUnlock( m_hDib ) ;
  260. return LOWORD(nWidth);
  261. }
  263. int  CImageFile::ImageHeight()
  264. {
  265. ASSERT(m_hDib != NULL);
  267. char far* lpDIB =(char far*)::GlobalLock( m_hDib ) ;
  268. LPBITMAPINFOHEADER lpbmi;  // pointer to a Win 3.0-style DIB
  269. LPBITMAPCOREHEADER lpbmc;  // pointer to an other-style DIB
  271. /* point to the header (whether old or Win 3.0 */
  273. lpbmi = (LPBITMAPINFOHEADER)lpDIB;
  274. lpbmc = (LPBITMAPCOREHEADER)lpDIB;
  277. long nHeight ;
  279. /* DIB height if it is a Win 3.0 DIB */
  280. if (IS_WIN30_DIB(lpDIB))
  281. nHeight = lpbmi->biHeight;
  282. else  /* it is an other-style DIB, so return its height */
  283. nHeight = (DWORD)lpbmc->bcHeight;
  285. ::GlobalUnlock( m_hDib ) ;
  287. return LOWORD(nHeight);
  288. }
  290. int  CImageFile::PaletteSize()
  291. {
  292. char far* lpbi =(char far*) ::GlobalLock( m_hDib ) ;
  293. int   nPaletteSize ;
  294. /* calculate the size required by the palette */
  295. if (IS_WIN30_DIB (lpbi))
  296. nPaletteSize = (WORD)( ImageNumColors() * sizeof(RGBQUAD));
  297.    else
  298. nPaletteSize = (WORD)( ImageNumColors() * sizeof(RGBTRIPLE));
  299.    ::GlobalUnlock( m_hDib ) ;
  300.    return nPaletteSize ;
  301. }  
  303. int  CImageFile::ImageNumColors()
  304. {
  305. WORD wBitCount;  // DIB bit count
  307. /*  If this is a Windows-style DIB, the number of colors in the
  308.  *  color table can be less than the number of bits per pixel
  309.  *  allows for (i.e. lpbi->biClrUsed can be set to some value).
  310.  *  If this is the case, return the appropriate value.
  311.  */
  312. char far* lpbi =(char far*)::GlobalLock( m_hDib ) ;
  314. if (IS_WIN30_DIB(lpbi))
  315. {
  316. DWORD dwClrUsed;
  318. dwClrUsed = ((LPBITMAPINFOHEADER)lpbi)->biClrUsed;
  319. if (dwClrUsed != 0)
  320. return (WORD)dwClrUsed;
  321. }
  323. /*  Calculate the number of colors in the color table based on
  324.  *  the number of bits per pixel for the DIB.
  325.  */
  326. if (IS_WIN30_DIB(lpbi))
  327. wBitCount = ((LPBITMAPINFOHEADER)lpbi)->biBitCount;
  328. else
  329. wBitCount = ((LPBITMAPCOREHEADER)lpbi)->bcBitCount;
  331. /* return number of colors based on bits per pixel */
  333. int nNumColors ;
  334. switch (wBitCount)
  335. {
  336. case 1:
  337. nNumColors = 2;
  338. break ;
  339. case 4:
  340. nNumColors = 16;
  341. break ;
  342. case 8:
  343. nNumColors =  256;
  344. break ;
  345. default:
  346. nNumColors = 0;
  347. break ;
  348. }
  349. ::GlobalUnlock( m_hDib ) ;
  350. return nNumColors ;
  351. } 
  353. //-------------------------------------------------------------------------------------//
  354. #define DIB_HEADER_MARKER   ((WORD) ('M' << 8) | 'B')
  356. #define INT_MAXNUM  65534
  358. CDibImage::CDibImage()
  359. {
  360. } 
  362. CDibImage::CDibImage(char* cFileName) : CImageFile(cFileName)
  363. {
  364. }
  366. CDibImage::~CDibImage()
  367. {
  368. }
  370. BOOL CDibImage::ReadImageFile() 
  371. {
  372. CFile file;
  373. CFileException fe;
  374. if (!file.Open(m_strFileName, CFile::modeRead | CFile::shareDenyWrite, &fe))
  375. {
  376. return FALSE;
  377. }
  379. // replace calls to Serialize with ReadDIBFile function
  380. TRY
  381. {
  382. ReadDIBFile(file);
  383. }
  384. CATCH (CFileException, eLoad)
  385. {
  386. file.Abort(); // will not throw an exception
  387. m_hDib = NULL;
  388. return FALSE;
  389. }
  390. END_CATCH
  392. InitDIBData();
  394. if (m_hDib == NULL)
  395. {
  396. // may not be DIB format
  397. MessageBox(NULL, "It is not DIB format !", NULL, MB_ICONINFORMATION | MB_OK);
  398. return FALSE;
  399. }
  401. return TRUE;
  402. }
  404. BOOL CDibImage::ReadDIBFile(CFile& file)
  405. {
  406. BITMAPFILEHEADER bmfHeader;
  407. DWORD dwBitsSize;
  408. LPSTR pDIB;
  410. /*
  411.  * get length of DIB in bytes for use when reading
  412.  */
  414. dwBitsSize = file.GetLength();
  416. /*
  417.  * Go read the DIB file header and check if it's valid.
  418.  */
  419. if (file.Read((LPSTR)&bmfHeader, sizeof(bmfHeader)) != sizeof(bmfHeader))
  420. return NULL;
  422. if (bmfHeader.bfType != DIB_HEADER_MARKER)
  423. return NULL;
  425. /*
  426.  * Allocate memory for DIB
  427.  */
  428. m_hDib = (HDIB)::GlobalAlloc(GMEM_MOVEABLE | GMEM_ZEROINIT, dwBitsSize);
  429. if (m_hDib == 0)
  430. {
  431. return FALSE;
  432. }
  433. pDIB = (LPSTR) ::GlobalLock((HGLOBAL) m_hDib);
  435. /*
  436.  * Go read the bits.
  437.  */
  438. if (file.ReadHuge(pDIB, dwBitsSize - sizeof(BITMAPFILEHEADER)) !=
  439. dwBitsSize - sizeof(BITMAPFILEHEADER) )
  440. {
  441. ::GlobalUnlock((HGLOBAL) m_hDib);
  442. ::GlobalFree((HGLOBAL) m_hDib);
  443. return FALSE;
  444. }
  445. ::GlobalUnlock((HGLOBAL) m_hDib);
  446. return TRUE ;
  447. }
  449. void CDibImage::InitDIBData()
  450. {
  451. if (m_palDIB != NULL)
  452. {
  453. delete m_palDIB;
  454. m_palDIB = NULL;
  455. }
  456. if (m_hDib == NULL)
  457. {
  458. return;
  459. }
  461. if (ImageWidth() > INT_MAXNUM ||ImageHeight() > INT_MAXNUM)
  462. {
  463. ::GlobalUnlock((HGLOBAL) m_hDib);
  464. ::GlobalFree((HGLOBAL) m_hDib);
  465. m_hDib = NULL;
  466. MessageBox(NULL, "DIB is too large", NULL,
  467.  MB_ICONINFORMATION | MB_OK);
  468. return;
  469. }
  470. // Create copy of palette
  471. m_palDIB = new CPalette;
  472. if (m_palDIB == NULL)
  473. {
  474. // we must be really low on memory
  475. ::GlobalFree((HGLOBAL) m_hDib);
  476. m_hDib = NULL;
  477. return;
  478. }
  479. if (CreatePalette( m_palDIB) == NULL)
  480. {
  481. // DIB may not have a palette
  482. delete m_palDIB;
  483. m_palDIB = NULL;
  484. return;
  485. }
  486. }
  488. /*
  489. void CDibImage::InitDIBData()
  490. {
  491. if (m_palDIB != NULL)
  492. {
  493. delete m_palDIB;
  494. m_palDIB = NULL;
  495. }
  496. if (m_hDib == NULL)
  497. {
  498. return;
  499. }
  500. if (ImageWidth() > INT_MAXNUM ||ImageHeight() > INT_MAXNUM)
  501. {
  502. ::GlobalUnlock((HGLOBAL) m_hDib);
  503. ::GlobalFree((HGLOBAL) m_hDib);
  504. m_hDib = NULL;
  505. MessageBox(NULL, "The image is too big !", NULL, MB_ICONINFORMATION | MB_OK);
  506. return;
  507. }
  509. // Create copy of palette
  510. m_palDIB = new CPalette;
  511. if (m_palDIB == NULL)
  512. {
  513. // we must be really low on memory
  514. ::GlobalFree((HGLOBAL) m_hDib);
  515. m_hDib = NULL;
  516. return;
  517. }
  518. if (CreatePalette(m_palDIB) == NULL)
  519. {
  520. // DIB may not have a palette
  521. delete m_palDIB;
  522. m_palDIB = NULL;
  523. return;
  524. }
  525. }
  526. */
  528. //----------------------------------------------------------------------------------------//
  529. // splash.cpp : implementation file
  530. //
  531. #ifdef _DEBUG
  532. #undef THIS_FILE
  533. static char BASED_CODE THIS_FILE[] = __FILE__;
  534. #endif
  536. /////////////////////////////////////////////////////////////////////////////
  537. // CSplashWnd
  539. IMPLEMENT_DYNCREATE(CSplashWnd, CView)
  541. CSplashWnd::CSplashWnd()
  542. {
  543. }
  545. CSplashWnd::~CSplashWnd()
  546. {
  547. DestroyWindow() ;
  548. }
  550. BOOL CSplashWnd::Create( LPSTR lpFileName)
  551. {   
  552. m_dibImage.CreateImage( lpFileName ) ;
  553. if(!m_dibImage.ReadImageFile()){
  554. AfxMessageBox( " Read DIB Image False ! " ) ;
  555.         return FALSE ;
  556.     }    
  557. int nImageWidth = m_dibImage.ImageWidth() ;
  558. int nImageHeight = m_dibImage.ImageHeight() ;
  559. CRect rect( 0,0,nImageWidth,nImageHeight);
  561. int nLeft,nTop ;
  562. nLeft = GetSystemMetrics( SM_CXSCREEN )/2 - nImageWidth/2 ;
  563. nTop = GetSystemMetrics( SM_CYSCREEN ) /2 - nImageHeight/2 ;
  564.     
  565.     CString str ;
  566.     str = AfxRegisterWndClass( NULL ) ;
  568. HWND hwnd = ::GetDesktopWindow() ;
  569. CWnd::CreateEx( WS_EX_TOPMOST,str , NULL , WS_POPUP , 
  570.                nLeft , nTop , nImageWidth , nImageHeight , NULL , NULL , NULL ) ;
  572.     return TRUE ;
  573. }                 
  575. BEGIN_MESSAGE_MAP(CSplashWnd, CWnd)
  576. //{{AFX_MSG_MAP(CSplashWnd)
  577. ON_WM_CREATE()
  578. ON_WM_PAINT()
  579. //}}AFX_MSG_MAP
  580. END_MESSAGE_MAP()
  582. /////////////////////////////////////////////////////////////////////////////
  583. // CSplashWnd message handlers
  584. int CSplashWnd::OnCreate(LPCREATESTRUCT lpCreateStruct)
  585. {
  586. if (CWnd::OnCreate(lpCreateStruct) == -1)
  587. return -1;
  588.     
  589.     return 0;
  590. }   
  592. void CSplashWnd::OnPaint()
  593. {
  594. CPaintDC dc(this); // device context for painting
  596. int nImageWidth = m_dibImage.ImageWidth() ;
  597. int nImageHeight = m_dibImage.ImageHeight() ;
  599. CRect rect( 0,0,nImageWidth,nImageHeight);
  600. m_dibImage.PaintImage( dc.m_hDC , &rect) ;
  601. }