由于windows绝大多数情况下运行于X86平台上，也就不存在不同平台的可移植性问题。然而Windows CE运行在四大架构（X86，SHx，MIPS，ARM）的CPU上，编写应用程序时就需要考虑它的移植。
       以下通过在wince系统下访问物理地址，来看看如何编写可移植性较好的应用程序。
       首先必须明确两个概念。
       1。在X86平台下才有I/O地址这一说，在其他体系的CPU（如ARM/MIPS）下是没有I/O端口的。因为X86下把I/O和存储器分开编址，导致其有两种地址；而别的CPU是把两者统一编址，即把I/O映射到存储器上。
        2。wince的存储管理是通过MMU实现的，在系统启动后，我们只能访问虚拟存储空间，必须经过MMU。但是在X86下，访问I/O口和存储器走的地址总线不同，不用经过MMU。
         比如我们想要访问挂在某总线上物理地址为360h的端口，对于X86平台我们可以直接嵌入汇编操作物理地址， 或者使用地址指针访问物理地址。但对于其他平台，我们必须先作一个物理地址到虚拟地址的映射，然后操作其虚拟地址。这样显然程序的可移植性不好，我们需要定义  #ifdef __x86....#elif defined __arm  使得在不同平台下程序能够顺利运行。
          如果使用下面的代码我们就可以不用这么费劲的定义不同平台了：
        先定义
     inIoSpace = 1;
    ioPhysicalBase.QuadPart = 0x360;

if( HalTranslateBusAddress( Isa,                 //此函数把ISA总线上物理地址映射为系统物理地址
                            0,
                            ioPhysicalBase,
                            &inIoSpace,                  //此参数=1说明转化的是I/O空间地址，=0时存储器地址
                            &ioPhysicalBase ) )
{
    if( !inIoSpace )                                           ////如果是存储器地址，针对非X86 平台

    {
            ioPortBase = ( PUCHAR ) MmMapIoSpace(            //此函数把系统物理地址转化为虚拟地址
            ioPhysicalBase,
            IoLen,
            FALSE );
        if( ioPortBase == NULL )
        {
            //TODO: Error handling
        }
    }
    else                                                 //如果是I/O，即X86 下，不需要做地址映射
    {
        ioPortBase = ( PUCHAR ) ioPhysicalBase.LowPart;
    }
}
else
{
    //TODO: Error Handling
}

       随后对于端口的操作（ ioPortBase），我们也可以充分挖掘它的可移植性。通过使用READ_PORT_UCHAR,
WRITE_PORT_UCHAR这些wince下的宏来实现端口读写。而不是在X86下用指针操作（不仅移植性差，而且容易产生问题）。CE下的宏在内部是封装好的API函数。例如WRITE_PORT_UCHAR这个宏在X86 处理器上转化为一条OUT的汇编指令；而在ARM处理器上会转化成一条对虚拟地址的写指令。

在进行ce的开发时，经常设计到字符的转换，特别是系统中包含网络通讯时，更是如此。ce中均是Unicode编码，而网络通讯一般都使用BYTE进行数据传输。

以下是在网上找到的一篇文章，介绍的很详细。

 1.使用方法详解

  在本文开始之处,先简要地说一下何为短字符和宽字符.
  所谓的短字符,就是用8bit来表示的字符,典型的应用是ASCII码.而宽字符,顾名思义,就是用16bit表示的字符,典型的有UNICODE.关于windows下的ASCII和UNICODE的更多信息,可以参考这两本经典著作:《windows 程序设计》,《windows 核心编程》.这两本书关于这两种字符都有比较详细的解说.
 
  宽字符转换为多个短字符是一个难点,不过我们只要掌握到其中的要领,便可如鱼得水.
  好吧,那就让我们开始吧.
 
  这个是我们需要转化的多字节字符串:  
  char sText[20] = {"多字节字符串!OK!"};
 
  我们需要知道转化后的宽字符需要多少个数组空间.虽然在这个里程里面,我们可以直接定义一个20*2宽字符的数组,并且事实上将运行得非常轻松愉快.但假如多字节字符串更多,达到上千个乃至上万个,我们将会发现其中浪费的内存将会越来越多.所以以多字节字符的个数的两倍作为宽字符数组下标的声明绝对不是一个好主意.
  所幸,我们能够确知所需要的数组空间.
  我们只需要将MultiByteToWideChar()的第四个形参设为-1,即可返回所需的短字符数组空间的个数:
  DWORD dwNum = MultiByteToWideChar (CP_ACP, 0, sText, -1, NULL, 0);
 
  接下来,我们只需要分配响应的数组空间:
  wchar_t *pwText;
  pwText = new wchar_t[dwNum];
  if(!pwText)
  {
   delete []pwText;
  }
 
  接着,我们就可以着手进行转换了.在这里以转换成ASCII码做为例子:
  MultiByteToWideChar (CP_ACP, 0, psText, -1, sText, dwSize);
 
  最后,使用完毕当然要记得释放占用的内存:
  delete []psText;
 
 
  同理,宽字符转为多字节字符的代码如下:  
  wchar_t wText[20] = {L"宽字符转换实例!OK!"};
  DWORD dwNum = WideCharToMultiByte(CP_OEMCP,NULL,lpcwszStr,-1,NULL,0,NULL,FALSE);
  char *psText;
  psText = new char[dwNum];
  if(!psText)
  {
   delete []psText;
  }
  WideCharToMultiByte (CP_OEMCP,NULL,lpcwszStr,-1,psText,dwNum,NULL,FALSE);
  delete []psText;
 
   如果之前我们已经分配好空间,并且由于字符串较短,可以不理会浪费的空间,仅仅只是想简单地将短字符和宽字符相互转换,那有没有什么简便的方法呢?
   WIN32 API里没有符合这种要求的函数,但我们可以自己进行封装:
     
  //-------------------------------------------------------------------------------------
  //Description:
  // This function maps a character string to a wide-character (Unicode) string
  //
  //Parameters:
  // lpcszStr: [in] Pointer to the character string to be converted
  // lpwszStr: [out] Pointer to a buffer that receives the translated string.
  // dwSize: [in] Size of the buffer
  //
  //Return Values:
  // TRUE: Succeed
  // FALSE: Failed
  //
  //Example:
  // MByteToWChar(szA,szW,sizeof(szW)/sizeof(szW[0]));
  //---------------------------------------------------------------------------------------
  BOOL MByteToWChar(LPCSTR lpcszStr, LPWSTR lpwszStr, DWORD dwSize)
  {
    // Get the required size of the buffer that receives the Unicode
    // string.
    DWORD dwMinSize;
    dwMinSize = MultiByteToWideChar (CP_ACP, 0, lpcszStr, -1, NULL, 0);
 
    if(dwSize < dwMinSize)
    {
     return FALSE;
    }
 
    
    // Convert headers from ASCII to Unicode.
    MultiByteToWideChar (CP_ACP, 0, lpcszStr, -1, lpwszStr, dwMinSize);  
    return TRUE;
  }
 
  //-------------------------------------------------------------------------------------
  //Description:
  // This function maps a wide-character string to a new character string
  //
  //Parameters:
  // lpcwszStr: [in] Pointer to the character string to be converted
  // lpszStr: [out] Pointer to a buffer that receives the translated string.
  // dwSize: [in] Size of the buffer
  //
  //Return Values:
  // TRUE: Succeed
  // FALSE: Failed
  //
  //Example:
  // MByteToWChar(szW,szA,sizeof(szA)/sizeof(szA[0]));
  //---------------------------------------------------------------------------------------
  BOOL WCharToMByte(LPCWSTR lpcwszStr, LPSTR lpszStr, DWORD dwSize)
  {
   DWORD dwMinSize;
   dwMinSize = WideCharToMultiByte(CP_OEMCP,NULL,lpcwszStr,-1,NULL,0,NULL,FALSE);
   if(dwSize < dwMinSize)
   {
    return FALSE;
   }
   WideCharToMultiByte(CP_OEMCP,NULL,lpcwszStr,-1,lpszStr,dwSize,NULL,FALSE);
   return TRUE;
  }
 
 
  使用方法也很简单,示例如下:
  wchar_t wText[10] = {L"函数示例"};
  char sText[20]= {0};
  WCharToMByte(wText,sText,sizeof(sText)/sizeof(sText[0]));
  MByteToWChar(sText,wText,sizeof(wText)/sizeof(wText[0]));
 
  这两个函数的缺点在于无法动态分配内存,在转换很长的字符串时可能会浪费较多内存空间;优点是,在不考虑浪费空间的情况下转换较短字符串非常方便.

 
2.MultiByteToWideChar()函数乱码的问题

  有的朋友可能已经发现,在标准的WinCE4.2或WinCE5.0 SDK模拟器下,这个函数都无法正常工作,其转换之后的字符全是乱码.及时更改MultiByteToWideChar()参数也依然如此.
  不过这个不是代码问题,其结症在于所定制的操作系统.如果我们定制的操作系统默认语言不是中文,也会出现这种情况.由于标准的SDK默认语言为英文,所以肯定会出现这个问题.而这个问题的解决,不能在简单地更改控制面板的"区域选项"的"默认语言",而是要在系统定制的时候,选择默认语言为"中文".
  系统定制时选择默认语言的位置于:
  Platform -> Setting... -> locale -> default language ,选择"中文",然后编译即可.

///////////////////////////////////////////////////
//
//  CDialogSK : dialog skin
//
//  writer: erran
//
//  time: 2006-03-24
//
///////////////////////////////////////////////////

＃i nclude "BaseSK.h"      /// EVC下实现WinCE软件换肤之函数TransparentBitBlt
＃i nclude "BitmapSK.h"   /// EVC下实现WinCE软件换肤之换肤基础类CBitmapSK 　

class CDialogSK: public CDialog
{

public:
 // constructor and Destructor
 CDialogSK();
 CDialogSK(LPCTSTR lpszTemplateName, CWnd* pParentWnd = NULL);
 CDialogSK(UINT nIDTemplate, CWnd* pParentWnd = NULL);
 ~CDialogSK();

protected:
 // common constructor
 Constructor(); 
 // Destructor,Release the bitmap
 Destructor();

protected:
 //window title text
 CString m_titleText;

protected:
 //interface bitmap
 CBitmapSK m_bmpLeft;  //dialog border left bitmap
 CBitmapSK m_bmpRight; //dialog border right bitmap
 CBitmapSK m_bmpBottom;//dialog border bottom bitmap
 CBitmapSK m_bmpTitle;   //two bitmap, dlg active and disactive
 CBitmapSK m_bmpTitleBtn;//max min close btn bitmap
 CBitmapSK m_bmpBkDlg; //dialog back ground bitmap
protected:
 //transparent color of bitmap
 COLORREF m_transColorLeft;
 COLORREF m_transColorRight;
 COLORREF m_transColorBottom;
 COLORREF m_transColorTitle;
 COLORREF m_transColorTitleBtn;
 COLORREF m_transColorBackDlg;

protected:

 //window border width and height
 // the border can not more than the border bmp size
 int m_borderLeftWidth;
 int m_borderRightWidth;
 int m_borderBottomHeight;
 int m_titleHeight;
 //offset in the bitmap
 int m_offsetLeft1, m_offsetLeft2;
 int m_offsetRight1, m_offsetRight2;
 int m_offsetBottom1, m_offsetBottom2;
 int m_offsetTitle1, m_offsetTitle2;

public:
 //window style
 BOOL m_titlable;
 BOOL m_sizable;
 BOOL m_minable;
 BOOL m_maxable;
 BOOL m_sysmenu;

 BOOL m_isActive;

public:
 BOOL m_winTransable;

public:
 //msg
 void OnPaint();
 BOOL OnEraseBkgnd(CDC* pDC);

public:
 // draw skin (x,y) is this dialog region
 BOOL DrawRight(CDC *pDC, int x, int y, int height, int state);
 BOOL DrawLeft(CDC *pDC, int x, int y, int height, int state);
 BOOL DrawBottom(CDC *pDC, int x, int y, int width, int state);
 BOOL DrawTitle(CDC *pDC, int x, int y, int width, int state);

 BOOL DrawFrame(CDC *pDC, int x, int y,int width, int height, int state);
 BOOL DrawBkDlg(CDC *pDC, int x, int y,int width, int height, int state); 
 
 BOOL DrawButton( CDC * pDC, int i, int state );

};

＃i nclude "stdafx.h"
＃i nclude "DialogSK.h"

/////////////////////////////////////////////////////////////////////////////
// CDialogSK dialog

CDialogSK::CDialogSK()
:CDialog()
{
}

CDialogSK::CDialogSK(LPCTSTR lpszTemplateName, CWnd* pParentWnd/*= NULL*/)
:CDialog(lpszTemplateName, pParentWnd)
{
}

CDialogSK::CDialogSK(UINT nIDTemplate, CWnd* pParentWnd/*/= NULL*/)
:CDialog(nIDTemplate, pParentWnd)
{
 
}

CDialogSK::~CDialogSK()
{
}

CDialogSK::Constructor()
{
   /*测试用
 m_bmpLeft.LoadBitmapEx(NULL, IDB_LEFT); 
 m_bmpRight.LoadBitmapEx(NULL, IDB_RIGHT);
 m_bmpBottom.LoadBitmapEx(NULL, IDB_BOTTOM);
 m_bmpTitle.LoadBitmapEx(NULL, IDB_TOP); 
  
 m_titleHeight = m_bmpTitle.Height()/2;
 m_borderLeftWidth = m_bmpLeft.Width()/2;
 m_borderRightWidth = m_bmpRight.Width()/2;
 m_borderBottomHeight = m_bmpBottom.Height()/2;

 m_offsetLeft1 = 10;
 m_offsetLeft2 = 10;
 m_offsetRight1 = 10;
 m_offsetRight2 = 10;
 m_offsetBottom1 = 10;
 m_offsetBottom2 = 10;
 m_offsetTitle1 = 10;
 m_offsetTitle2 = 10;
   */

}

CDialogSK::Destructor()
{
}

BOOL CDialogSK::DrawRight(CDC *pDC, int x, int y, int height, int state)
{ 
 int bmpwidth, bmpheight;
 m_bmpRight.Size(bmpwidth, bmpheight);

 //bitmap rect
 RECT srctop, srcmid, desmid, srcdown;

 if (state == 0)
 {
  srctop = CRect(0, 0, m_borderRightWidth, m_offsetRight1);
  srcmid = CRect(0, m_offsetRight1, m_borderRightWidth, m_offsetRight2);
  srcdown = CRect(0, m_offsetRight2, m_borderRightWidth, bmpheight);
 }
 else
 {
  srctop = CRect(m_borderRightWidth, 0, bmpwidth, m_offsetRight1);
  srcmid = CRect(m_borderRightWidth, m_offsetRight1, bmpwidth, m_offsetRight2);
  srcdown = CRect(m_borderRightWidth, m_offsetRight2, bmpwidth, bmpheight);
 }

 desmid = CRect(x, y+m_offsetRight1, x+m_borderRightWidth, y+height-bmpheight+m_offsetRight2);

 m_bmpRight.Draw(pDC, x, y, &srctop);
 m_bmpRight.Fill(pDC, &desmid, &srcmid);
 m_bmpRight.Draw(pDC, x, y+height-bmpheight+m_offsetRight2, &srcdown);

 return TRUE;
}

BOOL CDialogSK::DrawLeft(CDC *pDC, int x, int y, int height, int state)
{ 
 int bmpwidth, bmpheight;
 m_bmpLeft.Size(bmpwidth, bmpheight);

 //bitmap rect
 RECT srctop, srcmid, desmid, srcdown;

 if (state == 0)
 {
  srctop = CRect(0, 0, m_borderLeftWidth, m_offsetLeft1);
  srcmid = CRect(0, m_offsetLeft1, m_borderLeftWidth, m_offsetLeft2);
  srcdown = CRect(0, m_offsetLeft2, m_borderLeftWidth, bmpheight);
 }
 else
 {
  srctop = CRect(m_borderLeftWidth, 0, bmpwidth, m_offsetRight1);
  srcmid = CRect(m_borderLeftWidth, m_offsetLeft1, bmpwidth, m_offsetLeft2);
  srcdown = CRect(m_borderLeftWidth, m_offsetLeft2, bmpwidth, bmpheight);
 }

 desmid = CRect(x, y+m_offsetLeft1, x+m_borderLeftWidth, y+height-bmpheight+m_offsetLeft2);

 m_bmpLeft.Draw(pDC, x, y, &srctop);
 m_bmpLeft.Fill(pDC, &desmid, &srcmid);
 m_bmpLeft.Draw(pDC, x, y+height-bmpheight+m_offsetLeft2, &srcdown);

 return TRUE;
}

BOOL CDialogSK::DrawBottom(CDC *pDC, int x, int y, int width, int state)
{
 int bmpwidth, bmpheight;
 m_bmpBottom.Size(bmpwidth, bmpheight);

 RECT srcleft, srcmid, desmid, srcright;

 if (state == 0)
 {
  srcleft = CRect(0, 0, m_offsetBottom1, m_borderBottomHeight);
  srcmid = CRect(m_offsetBottom1, 0, m_offsetBottom2, m_borderBottomHeight);
  srcright = CRect(m_offsetBottom2, 0, bmpwidth, m_borderBottomHeight);
 }
 else
 {
  srcleft = CRect(0, m_borderBottomHeight, m_offsetBottom1, bmpheight);
  srcmid = CRect(m_offsetBottom1, m_borderBottomHeight, m_offsetBottom2, bmpheight);
  srcright = CRect(m_offsetBottom2, m_borderBottomHeight, bmpwidth, bmpheight);
 }
  
 desmid = CRect(x+m_offsetBottom1, y, x+width-bmpwidth+m_offsetBottom2, y+m_borderBottomHeight);

 m_bmpBottom.Draw(pDC, x, y, &srcleft);
 m_bmpBottom.Fill(pDC, &desmid, &srcmid);
 m_bmpBottom.Draw(pDC, x+width-bmpwidth+m_offsetBottom2, y, &srcright);

 return TRUE;
}

BOOL CDialogSK::DrawTitle(CDC *pDC, int x, int y, int width, int state)
{ 
 int bmpwidth, bmpheight;
 m_bmpTitle.Size(bmpwidth, bmpheight);

 RECT srcleft, srcmid, desmid, srcright;

 if (state == 0)
 {
  srcleft = CRect(0, 0, m_offsetTitle1, m_titleHeight);
  srcmid = CRect(m_offsetTitle1, 0, m_offsetTitle2, m_titleHeight);
  srcright = CRect(m_offsetTitle2, 0, bmpwidth, m_titleHeight);
 }
 else
 {
  srcleft = CRect(0, m_titleHeight, m_offsetTitle1, bmpheight);
  srcmid = CRect(m_offsetTitle1, m_titleHeight, m_offsetTitle2, bmpheight);
  srcright = CRect(m_offsetTitle2, m_titleHeight, bmpwidth, bmpheight);
 }

 desmid = CRect(x+m_offsetTitle1, y, x+width-bmpwidth+m_offsetTitle2, y+m_titleHeight);

 m_bmpTitle.Draw(pDC, x, y, &srcleft);
 m_bmpTitle.Fill(pDC, &desmid, &srcmid);
 m_bmpTitle.Draw(pDC, x+width-bmpwidth+m_offsetTitle2, y, &srcright);

 return TRUE;
}

BOOL CDialogSK::DrawFrame(CDC *pDC, int x, int y,int width, int height, int state)
{
 DrawTitle(pDC, x+m_borderLeftWidth, y, width-m_borderLeftWidth-m_borderRightWidth, state); 
 DrawLeft(pDC, x, y, height, state);
 DrawRight(pDC, x+width-m_borderRightWidth, y, height, state);
 DrawBottom(pDC, x+m_borderLeftWidth, y+height-m_borderBottomHeight, width-m_borderLeftWidth-m_borderRightWidth, state); 
 
 return TRUE;
}

BOOL CDialogSK::DrawBkDlg(CDC *pDC, int x, int y,int width, int height, int state)
{
 int bmpwidth, bmpheight;
 m_bmpBkDlg.Size(bmpwidth, bmpheight);
  
 RECT des, src;
 des = CRect(x,y, x+width, y+height);
 src = CRect(0, 0, bmpwidth, bmpheight);

 m_bmpBkDlg.Fill(pDC, &des, &src);

 return TRUE;
}

BOOL CDialogSK::OnEraseBkgnd(CDC* pDC)
{ 
 CRect rtClient = CClientRect(m_hWnd);
  
 DrawFrame(pDC, rtClient.left, rtClient.top, rtClient.Width(), rtClient.Height(),0);
 DrawBkDlg(pDC, rtClient.left+m_borderLeftWidth, rtClient.top+m_titleHeight,
       rtClient.Width()-m_borderLeftWidth-m_borderRightWidth,
       rtClient.Height()-m_titleHeight-m_borderBottomHeight,
             0);

 return TRUE;

}

呵呵，就这么多了，这里不方便贴图，要不可以看到效果的，呵呵，欢迎指教。

 //load bitmap by resource file path
 BOOL LoadBitmapEx(LPCTSTR lpszFileName);

 //load bitmap by resource name or ID
 BOOL LoadBitmapEx(LPCTSTR lpszResourceName, UINT nIDResource);

 //attaches a hBitmap to a CBitmap object.
 BOOL Attach(HBITMAP hbmp)
 {
     return CBitmap::Attach(hbmp);
 }
 
 void Size(int &width, int &height)
 {
    BITMAP bm;
    memset(&bm, 0, sizeof(bm));
    CBitmap::GetBitmap(&bm);
    width = bm.bmWidth;
    height = bm.bmHeight;
 }

 //bitmap width
 int Width(void)
 {
    BITMAP bm;
    memset(&bm, 0, sizeof(bm));
    CBitmap::GetBitmap(&bm);
    return bm.bmWidth;
 }

 //bitmap height
 int Height()
 {
    BITMAP bm;
    memset(&bm, 0, sizeof(bm));
    CBitmap::GetBitmap(&bm);
    return bm.bmHeight;
 }

 /////// src(bmp) ---> Des(pDC)

 //draw current bitmap to device(pDC rect(lpr)) 
 BOOL Draw(CDC *pDC, LPRECT lprDes);
 //draw current bitmap to device(pDC rect(lpr)) , transparent 
 BOOL Draw(CDC *pDC, LPRECT lprDes, COLORREF crTrans, BOOL isTrans);

 //draw sub bitmap(the rect lprSrc of current bitmap) to special point( the begin point (x,y) of pDC device)
 BOOL Draw(CDC *pDC, int x, int y, LPRECT lprSrc);
 //draw sub bitmap to special point
 BOOL Draw(CDC *pDC, int x, int y, LPRECT lprSrc, COLORREF crTrans, BOOL isTrans);

 BOOL Fill(CDC *pDC, LPRECT lprDes);
 BOOL Fill(CDC *pDC, LPRECT lprDes, COLORREF crTrans, BOOL isTrans);

 BOOL Fill(CDC *pDC, LPRECT lprDes, LPRECT lprSrc); 
 BOOL Fill(CDC *pDC, LPRECT lprDes, LPRECT lprSrc, COLORREF crTrans, BOOL isTrans);

 //Drawing Transparent Bitmaps,Copies a bitmap transparently onto the destination DC
 BOOL TransparentDraw(CDC * pDC, int x, int y, COLORREF crColour);
 

 //Copies a bitmap from a source rectangle into a destination rectangle,
 //stretching or compressing the bitmap if necessary to fit the dimensions of the destination rectangle.
 BOOL StretchDraw(CDC *pDC, LPRECT lprDes, LPRECT lprSrc);
 //Copies a bitmap from a source rectangle into a destination rectangle,
 //stretching or compressing the bitmap if necessary to fit the dimensions of the destination rectangle. 
 BOOL StretchDraw(CDC *pDC, LPRECT lprSrc);

 //make a region from bitmap, It will show as a window     ::: faulse function :::
 //HRGN CreateRegion(COLORREF crColour, BOOL isTrans = TRUE);  

};

{
 ASSERT(hdcDes!=NULL);//if(hdcDes == NULL) return FALSE;
 ASSERT(hbmSrc!=NULL);//if(hbmSrc == NULL) return FALSE;

 CDC dc, memDC, maskDC, tempDC;
 dc.Attach(hdcDes);
 maskDC.CreateCompatibleDC(&dc);
 CBitmap maskBmp;
 
 //add these to store return of SelectObject() calls
 CBitmap *pOldMemBmp = NULL;
 CBitmap *pOldMaskBmp = NULL;
 HBITMAP hOldTempBmp = NULL;
 
 memDC.CreateCompatibleDC(&dc);
 tempDC.CreateCompatibleDC(&dc);
 CBitmap bmpImage;
 bmpImage.CreateCompatibleBitmap(&dc, width, height);
 pOldMemBmp = memDC.SelectObject(&bmpImage);
 
 // Select and realize the palette
 if( dc.GetDeviceCaps(RASTERCAPS) & RC_PALETTE && hPal )
 {
  ::SelectPalette(dc, hPal, FALSE);
  dc.RealizePalette();
  
  ::SelectPalette(memDC, hPal, FALSE);
 }
 
 hOldTempBmp = (HBITMAP)::SelectObject(tempDC.m_hDC, hbmSrc);
 
 memDC.BitBlt(0, 0, width, height, &tempDC, xSrc, ySrc, SRCCOPY);
 
 // Create monochrome bitmap for the mask
 maskBmp.CreateBitmap(width, height, 1, 1, NULL);
 pOldMaskBmp = maskDC.SelectObject(&maskBmp);
 memDC.SetBkColor(crTrans);
 
 // Create the mask from the memory DC
 maskDC.BitBlt(0, 0, width, height, &memDC, 0, 0, SRCCOPY);
 
 // Set the background in memDC to black. Using SRCPAINT with black
 // and any other color results in the other color, thus making
 // black the transparent color
 memDC.SetBkColor(RGB(0,0,0));
 memDC.SetTextColor(RGB(255,255,255));
 memDC.BitBlt(0, 0, width, height, &maskDC, 0, 0, SRCAND);
 
 // Set the foreground to black. See comment above.
 dc.SetBkColor(RGB(255,255,255));
 dc.SetTextColor(RGB(0,0,0));
 dc.BitBlt(xDes, yDes, width, height, &maskDC, 0, 0, SRCAND);
 
 // Combine the foreground with the background
 dc.BitBlt(xDes, yDes, width, height, &memDC, 0, 0, SRCPAINT);
 
 
 if (hOldTempBmp)
  ::SelectObject(tempDC.m_hDC, hOldTempBmp);
 if (pOldMaskBmp)
  maskDC.SelectObject(pOldMaskBmp);
 if (pOldMemBmp)
  memDC.SelectObject(pOldMemBmp);
 
 dc.Detach();

 maskBmp.DeleteObject();
 bmpImage.DeleteObject();

 maskDC.DeleteDC();
 memDC.DeleteDC();
 tempDC.DeleteDC();

 pOldMemBmp = NULL;
 pOldMaskBmp = NULL;
 hOldTempBmp = NULL;

 return TRUE;
}

///}}} for global function

另三个很有意思的类，从高手那“盗”来的，呵呵:

class CWinRect: public CRect
{
public:
 CWinRect(HWND hWnd)
 {
  ::GetWindowRect(hWnd, this);
 }
 CWinRect(const CWnd *pWnd)
 {
  ::GetWindowRect(pWnd->GetSafeHwnd(), this);
 }

};

class CWinText: public CString
{
public:
 CWinText(HWND hWnd)
 {
  (CWnd::FromHandle(hWnd))->GetWindowText(*this); 
 }
 CWinText(const CWnd *pWnd)
 {
  pWnd->GetWindowText(*this);
 }
};

class CClientRect: public CRect
{
public:
 CClientRect(HWND hWnd)
 {
  ::GetClientRect(hWnd, this);
 }
 CClientRect(CWnd *pWnd)
 {
  ::GetClientRect(pWnd->GetSafeHwnd(), this);
 }
};

    在此做了个简单的ocx试了试，能够在EVC4.2/模拟器wince4.2下成功。具体步骤如下：

    1. 开发CE版OCX控件。先在EVC中开发自己的OCX控件。编译成功以后，ocx会被自动下载到模拟器里去。

    2. 在模拟器中注册该控件.注册方法：用EVC的remote filter viewer加载目录C:\Program Files\Microsoft eMbedded C++ 4.0\EVC\WCE400\TARGET\X86\regsvrce.exe到模拟器windows目录下。或者直接拷贝该regsvrce.exe到模拟器里。拷贝成功后，在模拟器上运行regsvrce.exe，注册控件，如运行“regsvrce CEActivexBtn.ocx”,即注册了CEActivexBtn 控件。

    4. 开发win32版OCX控件。在VC中创建一个和以上工程名字一样的工程（必须一样，否则回不成功），把该工程（vc工程）下的 两个工程文件dsw和dsp拷贝到CE版控件工程的目录下，和vcw和vcp放到同一个目录下，然后打开这个目录下的VC工程，发现编译配置里选择的是“Win32 Unicode Debug”，编译，可能会产生链接错误，即差mfc42ud;lib。当然如果VC安装的很完善的话，不会产生这个错误。不过也没关系，把那个配置改了，改成“Win32 Debug”，这样就能编译成功了。编译完成，VC会自动注册该win32版的ocx控件。

　　5．在EVC上添加该Win32版的（不是CE版的）ocx控件。方法，创建一个demo工程，在该工程的对话筐编辑器里，右键菜单“Insert ActiveX Controls”，出现Insert ActiveX Controls窗口，点击“Add Controls”按钮，找到用VC编译的Win32版ocx控件，添加。

　　OK！现在可以在EVC上调用该ocx编程了。

最初使用的截屏方法说来还真有些丢人，一个一个点的取得颜色值，再保存到bmp文件中去，这样程序运行的速度超慢，保存一个800X600的bmp差不多要一两分钟（研华8251板），觉得有些不对头，决定想办法改进一下，就使劲地看了一下Charles Petzold先生的《Programming Windows》（这本书很经典，值得好好研究一下），终于把时间缩短到几秒钟了，下面这个函数在evc和vc下都test pass(不用更改)，有不足之处欢迎指正，函数：

// this function create a bmp file to save the current screen;
// supported eVC++ 4.0 (wince 4.0) and vc++ 6.0 , test pass;
void CSnapDlg::OnScreenSave(const char *filename)
{ 
    HDC  hScrDC, hMemDC;        
    int  width, height; 
 
 //the pointer will save all pixel point's color value
 BYTE  *lpBitmapBits = NULL;
       
 //creates a device context for the screen device
    hScrDC = CreateDC(_T("DISPLAY"), NULL, NULL, NULL);

  //get the screen point size
    width = GetDeviceCaps(hScrDC, HORZRES);
    height = GetDeviceCaps(hScrDC, VERTRES);

    //creates a memory device context (DC) compatible with the screen device(hScrDC) 
    hMemDC = CreateCompatibleDC(hScrDC);

 //initialise the struct BITMAPINFO for the bimap infomation，
 //in order to use the function CreateDIBSection
 // on wince os, each pixel stored by 24 bits(biBitCount=24) 
 //and no compressing(biCompression=0)
    BITMAPINFO RGB24BitsBITMAPINFO;
    ZeroMemory(&RGB24BitsBITMAPINFO, sizeof(BITMAPINFO));
    RGB24BitsBITMAPINFO.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
    RGB24BitsBITMAPINFO.bmiHeader.biWidth = width;
    RGB24BitsBITMAPINFO.bmiHeader.biHeight = height;
    RGB24BitsBITMAPINFO.bmiHeader.biPlanes = 1;
    RGB24BitsBITMAPINFO.bmiHeader.biBitCount = 24;
  
  //use the function CreateDIBSection and SelectObject 
 //in order to get the bimap pointer : lpBitmapBits
    HBITMAP directBmp = CreateDIBSection(hMemDC, (BITMAPINFO*)&RGB24BitsBITMAPINFO,
       DIB_RGB_COLORS, (void **)&lpBitmapBits, NULL, 0);
 HGDIOBJ previousObject = SelectObject(hMemDC, directBmp);

 // copy the screen dc to the memory dc
 BitBlt(hMemDC, 0, 0, width, height, hScrDC, 0, 0, SRCCOPY);
 
 //if you only want to get the every pixel color value,
 //you can begin here and the following part of this function will be unuseful;
 //the following part is in order to write file;

 //bimap file header in order to write bmp file
 BITMAPFILEHEADER bmBITMAPFILEHEADER;
 ZeroMemory(&bmBITMAPFILEHEADER, sizeof(BITMAPFILEHEADER));
 bmBITMAPFILEHEADER.bfType = 0x4d42;  //bmp 
    bmBITMAPFILEHEADER.bfOffBits = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER);
    bmBITMAPFILEHEADER.bfSize = bmBITMAPFILEHEADER.bfOffBits + ((width*height)*3); ///3=(24 / 8)
 
 //write into file
 FILE *mStream = NULL;
 if((mStream = fopenfilename, "wb")))
 {  
  //write bitmap file header
  fwrite(&bmBITMAPFILEHEADER, sizeof(BITMAPFILEHEADER), 1, mStream);
  //write bitmap info
  fwrite(&(RGB24BitsBITMAPINFO.bmiHeader), sizeof(BITMAPINFOHEADER), 1, mStream);
  //write bitmap pixels data
  fwrite(lpBitmapBits, 3*width*height, 1, mStream);
   //close file
  fclose(mStream);
 }
 
 //delete
 DeleteObject(hMemDC);
 DeleteObject(hScrDC);
 DeleteObject(directBmp);
 DeleteObject(previousObject);
}

还是用英语作了注释，虽然英语学的很糟糕，还是觉得这个习惯比较好~~ ..