MFC本身的CView类是支持拖放操作的，通过研究CView类的源码，大体知道它的实现原理是这样的：CView类中有一个COleDropTarget类的对象，在视图窗口初始化时，调用COleDropTarget类成员函数Register()，以此在系统中注册该视图窗口为拖放接收窗口。当进行拖放操作的鼠标指针处于视图窗口范围内时，COleDropTarge类会做出反应，它的OnDragEnter、OnDragOver、OnDropEx、OnDrop等成员函数被依次调用，这些函数默认均是调用与其相对应的CView类成员函数OnDragEnter、OnDragOver、OnDropEx、OnDrop等，程序员只需重载这些CView类成员函数，即可对拖动的过程及结果进行控制。

因为COleDropTarget默认只对CView提供支持，所以如果要让其他的窗口支持拖放，我们必须同时对要支持拖放的窗口类和COleDropTarget类进行派生。把对拖放操作具体进行处理的代码封装成派生窗口类的成员函数，然后重载COleDropTarget中对应的五个虚函数，当它接收到拖放动作时，调用窗口派生类的处理函数即可。但这里有一个问题，就是我们怎么知道何时调用派生类的处理函数呢？答案是运用RTTI技术。如果COleDropTarget派生类收到的窗口指针类型，就是我们派生的窗口类，那么就调用它的处理函数，否则调用基类进行处理。

首先生成一个对话框工程，添加二个新类。

第一个类名为CListCtrlEx，父类为CListCtrl。添加完毕后，在CListCtrlEx的定义头文件中加入DECLARE_DYNAMIC(CListCtrlEx)，在其实现文件中加入IMPLEMENT_DYNAMIC(CListCtrlEx,CListCtrl)，这样就对CListCtrlEx类添加了RTTI运行期类型识别（Run Time Type Information）支持。

第二个类名为COleDropTargetEx，父类为COleDataTarget。

在CListCtrlEx中添加COleDropTargetEx类的对象，并添加下列公有虚函数的声明：

       virtual BOOL Initialize();

       virtual DROPEFFECT OnDragOver(CWnd* pWnd, COleDataObject* pDataObject, DWORD dwKeyState, CPoint point);

       virtual DROPEFFECT OnDropEx(CWnd* pWnd, COleDataObject* pDataObject, DROPEFFECT dropEffect, DROPEFFECT dropList, CPoint point);

       virtual BOOL OnDrop(CWnd* pWnd, COleDataObject* pDataObject, DROPEFFECT dropEffect, CPoint point);

       virtual void OnDragLeave(CWnd* pWnd);

Initialize函数用于注册CListCtrlEx成为拖放接收窗口；

OnDragOver在拖放鼠标进入窗口时被调用。此函数的返回值决定了后续的动作的类型：如果返回DROPEFFECT_MOVE，则产生一个剪切动作；如果返回DROPEFFECT_COPY，则产生一个复制动作，如果返回DROPEFFECT_NONE，则不会产生拖放动作，因为OnDropEx、OnDrop函数将不会被调用（OnDragLeave函数仍会被调用）。

OnDropEx函数会在OnDrop函数之前调用，如果OnDropEx函数没有对拖放动作进行处理，则应用程序框架会接着调用OnDrop函数进行处理。所以必须要在派生类中重载OnDropEx函数——即使什么动作都都没有做——否则我们的OnDrop函数将不会被执行到，因为没有重载的话，将会调用基类的OnDropEx函数，而基类的OnDropEx函数对拖放是进行了处理的——尽管不是我们所想要的动作。当然你也可以把对拖放进行处理的动作放在OnDropEx中——那样就不需要重载OnDrop了。

OnDragLeave函数会在鼠标离开窗口时被调用，在此可以进行一些简单的清理工作。譬如在OnDragEnter或者OnDragOver函数中，我们改变了光标的形态，那么此时我们就应该把光标恢复过来。

这些函数中最重要的是OnDrop函数，拖放动作将在此进行处理，它的全部源码如下：

BOOL CListCtrlEx::OnDrop(CWnd* pWnd, COleDataObject* pDataObject, DROPEFFECT dropEffect, CPoint point)

{

       UINT              nFileCount = 0;

       HDROP           hDropFiles = NULL;

       HGLOBAL        hMemData = NULL;

       AfxMessageBox("OnDrop");

       if(pDataObject->IsDataAvailable(CF_HDROP))

       {

              hMemData = pDataObject->GetGlobalData(CF_HDROP);

              hDropFiles = (HDROP)GlobalLock((HGLOBAL)hMemData); //锁定内存块

              if(hDropFiles != NULL)

              {

                     char chTemp[_MAX_PATH+1] = {0};

                     nFileCount = DragQueryFile(hDropFiles, 0xFFFFFFFF, NULL, 0);

                     for(UINT nCur=0; nCur<nFileCount; ++nCur) //遍历取得每个文件名

                     {

                            ZeroMemory(chTemp, _MAX_PATH+1);

                DragQueryFile(hDropFiles, nCur, (LPTSTR)chTemp, _MAX_PATH+1);

                            AddAllFiles(chTemp);

                     }

              }

              GlobalUnlock(hMemData);

              return TRUE;

       }

       else

       {

              return FALSE;

       }

}

在第二个类COleDropTarget中添加如下对应的函数：

    virtual DROPEFFECT OnDragEnter(CWnd* pWnd, COleDataObject* pDataObject, DWORD dwKeyState, CPoint point);

    virtual DROPEFFECT OnDragOver(CWnd* pWnd, COleDataObject* pDataObject, DWORD dwKeyState, CPoint point);

       virtual DROPEFFECT OnDropEx(CWnd* pWnd, COleDataObject* pDataObject, DROPEFFECT dropEffect, DROPEFFECT dropList, CPoint point);

       virtual BOOL OnDrop(CWnd* pWnd, COleDataObject* pDataObject, DROPEFFECT dropEffect, CPoint point);

       virtual void OnDragLeave(CWnd* pWnd);

它们的动作都差不多：先用RTTI判断窗口指针pWnd的类型，如果是CListCtrlEx，则调用CListCtrlEx中对应的处理函数，否则调用基类的处理函数。以OnDrop为例：

BOOL COleDropTargetEx::OnDrop(CWnd* pWnd, COleDataObject* pDataObject, DROPEFFECT dropEffect, CPoint point)

{

       CListCtrlEx*     pListCtrlEx = NULL;

       ASSERT_VALID(this);

       ASSERT(IsWindow(pWnd->m_hWnd));

       if(pWnd->IsKindOf(RUNTIME_CLASS(CListCtrlEx)))

       {

              pListCtrlEx = (CListCtrlEx*)pWnd;

              return pListCtrlEx->OnDrop(pWnd, pDataObject, dropEffect, point);

       }

       else

       {

              return COleDropTarget::OnDrop(pWnd, pDataObject, dropEffect, point);    

       }

}

//倒霉的64K限制，只能再截断了：（

至此，我们成功地为CListCtrlEx添加了文件拖入操作的支持。一个完整的拖放操作，还包括拖出动作，所以必须要为该类再添加拖出操作，即，将列表中的某一项或者多项拖出成为一个文件。这就需要用到另一个类：COleDataSource。具体步骤如下：

在CListCtrlEx中加入一个COleDataSource的实例，并映射列表框的LVN_BEGINDRAG消息处理函数，在此我们添加拖出操作的代码。

实现拖出非常简单，只需要依次调用COleDataSource的三个函数即可：Empty用于清空原先对象中缓存的数据，CacheGlobalData用来缓存数据以进行拖放操作，最后调用DoDragDrop启动本次拖放操作。

但在调用之前，必须要做一些准备工作。主要的任务就是创建一个DROPFILES结构体，并拷贝要拖放的文件名到结构体后的内存中。DROPFILES结构体定义了CF_HDROP剪贴板格式，紧跟它后面的是一系列被拖放文件的路径名。它的定义如下：

typedef struct _DROPFILES

{

    DWORD     pFiles;  //文件名起始地址

    POINT      pt;     //鼠标放下的位置，坐标由fNC成员指定

    BOOL        fNC;    //为TRUE表示适用屏幕坐标系，否则使用客户坐标系

    BOOL        fWide;  //文件名字符串是否使用宽字符

} DROPFILES, FAR* LPDROPFILES;

拖放之前的准备动作的代码如下：

uBufferSize = sizeof(DROPFILES) + uBufferSize + 1;

    hMemData = GlobalAlloc(GPTR,uBufferSize);

    ASSERT(hMemData != NULL);

       lpDropFiles = (LPDROPFILES)GlobalLock(hMemData); //锁定之,并设置相关成员

       ASSERT(lpDropFiles != NULL);

       lpDropFiles->pFiles = sizeof(DROPFILES);

#ifdef _UNICODE

       lpDropFiles->fWide = TRUE;

#else

       lpDropFiles->fWide = FALSE;

#endif

       //把选中的所有文件名依次复制到DROPFILES结构体后面(全局内存中)

       pItemPos = strSelectedList.GetHeadPosition();

       pszStart = (char*)((LPBYTE)lpDropFiles + sizeof(DROPFILES));

       while(pItemPos != NULL)

       {

              lstrcpy(pszStart, (LPCTSTR)strSelectedList.GetNext(pItemPos));

        pszStart = strchr(pszStart,'\0') + 1; //下次的起始位置是上一次结尾+1

       }

准备完毕之后就可以进行拖放了，拖放动作有DoDragDrop函数触发，其原型如下：

DROPEFFECT DoDragDrop(

DWORD dwEffects = DROPEFFECT_COPY|DROPEFFECT_MOVE|DROPEFFECT_LINK, LPCRECT lpRectStartDrag = NULL,

COleDropSource* pDropSource = NULL

);

这里，dwEffects指定了允许施加于本COleDataSource实例之上的动作集：剪切、复制或无动作。

    lpRectStartDrag指示拖放操作真正开始的矩形，如果鼠标没有移出该矩形，则拖放操作视作放弃处理。如果本成员设为NULL，则该起始矩形将为一个像素大小。

    pDropSource表明拖放所使用的COleDataSource对象。

而该函数的返回值，则表明本次拖放操作所实际产生的效果，至于具体产生何种效果，则由系统决定。譬如在拖放时按住Shift键，将产生剪切效果；按住Ctrl键，将产生复制效果，等等。

拖放的代码如下：

       m_oleDataSource.Empty();

       m_oleDataSource.CacheGlobalData(CF_HDROP, hMemData);

       DropResult = m_oleDataSource.DoDragDrop(DROPEFFECT_MOVE|DROPEFFECT_COPY);

最后一点要注意的是，在Windows NT 4.0以上的系统中，即使实际产生的是DROPEFFECT_MOVE动作，DoDragDrop函数也只返回DROPEFFECT_NONE。产生这个问题的原因在于，Windows NT 4.0的Shell会直接移动文件本身来对移动操作进行优化。返回值DROPEFFECT_MOVE最初的含义，就是通知执行拖放操作的应用程序去删除原位置上的文件。但是因为Shell已经替应用程序完成了这个（删除）动作，所以，函数返回DROPEFFECT_NONE。要想知道文件是否真的被移动了也很简单，只要在函数返回之后检查一下原位置上的文件是否存在就可以了。

Windows 9x系列的操作系统也会对移动进行同样的优化动作，但是它不会返回DROPEFFECT_NONE来代替DROPEFFECT_MOVE。详细的解释参见MS知识库Q182219。

The following code shows how to obtain the filename or path and description of a given link file:

   #include <windows.h>
#include <shlobj.h>
// GetLinkInfo() fills the filename and path buffer
// with relevant information.
// hWnd         - calling application's window handle.
//
// lpszLinkName - name of the link file passed into the function.
//
// lpszPath     - the buffer that receives the file's path name.
//
// lpszDescription - the buffer that receives the file's
// description.
HRESULT
GetLinkInfo( HWND    hWnd,
LPCTSTR lpszLinkName,
LPSTR   lpszPath,
LPSTR   lpszDescription)
{
HRESULT hres;
IShellLink *pShLink;
WIN32_FIND_DATA wfd;
// Initialize the return parameters to null strings.
*lpszPath = '\0';
*lpszDescription = '\0';
// Call CoCreateInstance to obtain the IShellLink
// Interface pointer. This call fails if
// CoInitialize is not called, so it is assumed that
// CoInitialize has been called.
hres = CoCreateInstance( &CLSID_ShellLink,
NULL,
CLSCTX_INPROC_SERVER,
&IID_IShellLink,
(LPVOID *)&pShLink );
if (SUCCEEDED(hres))
{
IPersistFile *ppf;
// The IShellLink Interface supports the IPersistFile
// interface. Get an interface pointer to it.
hres = pShLink->lpVtbl->QueryInterface(pShLink,
&IID_IPersistFile,
(LPVOID *)&ppf );
if (SUCCEEDED(hres))
{
WORD wsz[MAX_PATH];
// Convert the given link name string to a wide character string.
MultiByteToWideChar( CP_ACP, 0,
lpszLinkName,
-1, wsz, MAX_PATH );
// Load the file.
hres = ppf->lpVtbl->Load(ppf, wsz, STGM_READ );
if (SUCCEEDED(hres))
{
// Resolve the link by calling the Resolve() interface function.
// This enables us to find the file the link points to even if
// it has been moved or renamed.
hres = pShLink->lpVtbl->Resolve(pShLink,  hWnd,
SLR_ANY_MATCH | SLR_NO_UI);
if (SUCCEEDED(hres))
{
// Get the path of the file the link points to.
hres = pShLink->lpVtbl->GetPath( pShLink, lpszPath,
MAX_PATH,
&wfd,
SLGP_SHORTPATH );
// Only get the description if we successfully got the path
// (We can't return immediately because we need to release ppf &
//  pShLink.)
if(SUCCEEDED(hres))
{
// Get the description of the link.
hres = pShLink->lpVtbl->GetDescription(pShLink,
lpszDescription,
MAX_PATH );
}
}
}
ppf->lpVtbl->Release(ppf);
}
pShLink->lpVtbl->Release(pShLink);
}
return hres;
}

• Arial Regular

• Arial Bold

• Arial Italic

• Arial Bold Italic

GDI+ 使用四种字形形成字体系列：常规、粗体、倾斜和粗斜体。像 narrow 和 rounded 之类的形容词不被视为字形；而是作为字体系列名的一部分。例如，Arial Narrow 是包含以下成员的字体系列：

• Arial Narrow Regular

• Arial Narrow Bold

• Arial Narrow Italic

• Arial Narrow Bold Italic

在可以使用 GDI+ 绘制文本之前，您需要构造一个 FontFamily 对象和一个 Font 对象。FontFamily 对象指定字样（例如 Arial），而 Font 对象指定字号、字形和单位。

示例

下面的示例构造一个字号为 16 像素、常规字形的 Arial 字体。在下面的代码中，传递给 Font 构造函数的第一个参数是 FontFamily 对象。第二个参数指定字体的大小，其单位由第四个参数确定。第三个参数确定字形。

Pixel 为 GraphicsUnit 枚举的一个成员，Regular 是 FontStyle 枚举的一个成员。

FontFamily fontFamily = new FontFamily("Arial");
Font font = new Font(
       fontFamily,
       16,
       FontStyle.Regular,
       GraphicsUnit.Pixel);

由于作图过于复杂和频繁，所以时常出现闪烁的情况，一些防止闪烁的方法，如下：

(1)将Invalidate()替换为InvalidateRect()。
Invalidate()会导致整个窗口的图象重画，需要的时间比较长，而InvalidateRect()仅仅重画Rect区域内的内容，所以所需时间会少一些。不要为一小块区域的重画就调用Invalidate()，不愿意自己去计算需要重画的Rect，事实上，如果你确实需要改善闪烁的情况，计算一个Rect所用的时间比起重画那些不需要重画的内容所需要的时间要少得多。

(2)禁止系统擦除你的窗口。
系统在需要重画窗口的时候会帮你用指定的背景色来擦除窗口。可是，也许需要重画的区域也许非常小。或者，在你重画这些东西之间还要经过大量的计算才能开始.这个时候你可以禁止系统擦掉原来的图象。直到你已经计算好了所有的数据，自己把那些需要擦掉的部分用背景色覆盖掉（如：dc.FillRect(rect，&brush)；rect是需要擦除的区域，brush是带背景色的刷子），再画上新的图形。要禁止系统擦除你的窗口，可以重载OnEraseBkgnd()函数，让其直接返回TRUE就可以了。如
BOOL CmyWin::OnEraseBkgnd(CDC* pDC)
{
 return TRUE;
 //return CWnd::OnEraseBkgnd(pDC);//把系统原来的这条语句注释掉。
}

(3)有效的进行擦除。
擦除背景的时候，不要该擦不该擦的地方都擦。比如，你在一个窗口上放了一个很大的Edit框，几乎占了整个窗口，那么你频繁的擦除整个窗口背景将导致Edit不停重画形成剧烈的闪烁.事实上你可以CRgn创建一个需要擦除的区域，只擦除这一部分.如

GetClientRect(rectClient);
rgn1.CreateRectRgnIndirect(rectClient);
rgn2.CreateRectRgnIndirect(m_rectEdit);

if(rgn1.CombineRgn(&rgn1,&rgn2,RGN_XOR)= ERROR)
//处理后的rgn1只包括了Edit框之外的客户区域，这样，Edit将不会被我的背景覆盖而导致重画.
{
 ASSERT(FALSE);
 return ;
}
brush.CreateSolidBrush(m_clrBackgnd);
pDC->FillRgn(&rgn1,&brush);
brush.DeleteObject();
注意：在使用这个方法的时候要同时使用方法二。

(4).使用MemoryDC先在内存里把图画好，再复制到屏幕上。
这对于一次画图过程很长的情况比较管用。毕竟内存操作比较快，而且复制到屏幕又是一次性的，至少不会出现可以明显看出一个东西从左画到右的情况。

void CMyWiew：：OnDraw() //CScrollView下双缓冲内存的实现：
{
 CRect rect;
 GetClientRect(&rect);

 CDC* m_pMemoryDC = new CDC();
 CBitmap * m_pBitmap = new CBitmap();

 CPoint ScrollPoint=GetScrollPosition();

 m_pMemoryDC->CreateCompatibleDC(pDC);
  
 m_pBitmap->CreateCompatibleBitmap(pDC,rect.right+1,rect.bottom+1);//这里的Bitmap是必须的，否则当心弄出一个大黑块. 
 CBitmap * pOldbmp=m_pMemoryDC->SelectObject(m_pBitmap);

 //m_pMemoryDC->SelectStockObject(WHITE_BRUSH);//画出白色背景方法一
 //m_pMemoryDC->Rectangle(-1,-1,rect.right + 2 , rect.bottom + 2 );
 //m_pMemoryDC->SelectStockObject(NULL_BRUSH);

 m_pMemoryDC->PatBlt(0,0,rect.right, rect.bottom,WHITENESS);//画出白色背景方法二

 //-----------------如下是显示图片的方法----------------------------------------------------------
 //BITMAP BM;
 //CBitmap  pBitmap;
 //pBitmap.LoadBitmap(IDB_BITMAP2);
 
 //CDC * pTdc = new CDC();
 //pTdc->CreateCompatibleDC(pDC);
 //CBitmap* pom = pTdc->SelectObject(&pBitmap);
 //pBitmap->GetObject(sizeof(BM),&BM);
 //m_pMemoryDC->BitBlt(0-ScrollPoint.x,0-ScrollPoint.y, BM.bmWidth,BM.bmHeight, pTdc,0,0,SRCCOPY);
 //pTdc->DeleteDC();
 //delete pTdc;
 //--------------图片显示完毕----------------------------------------------------------------------

 //m_pMemoryDC->SetROP2(R2_NOT);//设定绘图模式

 m_pMemoryDC->MoveTo(0-ScrollPoint.x,0-ScrollPoint.y);
 m_pMemoryDC->LineTo(1000-ScrollPoint.x,5000-ScrollPoint.y);

 pDC->BitBlt(ScrollPoint.x, ScrollPoint.y, rect.right, rect.bottom, m_pMemoryDC, 0, 0, SRCCOPY);

 m_pMemoryDC->SelectObject(pOldbmp); 
 m_pBitmap->DeleteObject();
 m_pMemoryDC->DeleteDC();

 delete m_pBitmap;
 delete m_pMemoryDC;
}

*******************************

一般的windows 复杂的界面需要使用多层窗口而且要用贴图来美化，所以不可避免在窗口移动或者改变大小的时候出现闪烁。

先来谈谈闪烁产生的原因

原因一：
如果熟悉显卡原理的话，调用GDI函数向屏幕输出的时候并不是立刻就显示在屏幕
上只是写到了显存里，而显卡每隔一段时间把显存的内容输出到屏幕上，这就是刷新周期。

一般显卡的刷新周期是 1/80秒左右，具体数字可以自己设置的。

这样问题就来了，一般画图都是先画背景色，然后再把内容画上去，如果这两次操作不在同一个
刷新周期内完成，那么给人的视觉感受就是，先看到只有背景色的图像，然后看到画上内容的图像，
这样就会感觉闪烁了。

解决方法：尽量快的输出图像，使输出在一个刷新周期内完成，如果输出内容很多比较慢，那么采用
内存缓冲的方法，先把要输出的内容在内存准备好，然后一次输出到显存。要知道一次API调用一般可以
在一个刷新周期内完成。

对于GDI，用创建内存DC的方法就可以了

原因二：

复杂的界面有多层窗口组成，当windows在窗口改变大小的时候是先重画父窗口，然后重画子窗口，子父
窗口重画的过程一般无法在一个刷新周期内完成，所以会呈现闪烁。

我们知道父窗口上被子窗口挡住的部分其实没必要重画的

解决方法：给窗口加个风格 WS_CLIPCHILDREN ,这样父窗口上被子窗口挡住的部分就不会重画了。

如果同级窗口之间有重叠，那么需要再加上 WS_CLIPSIBLINGS 风格

原因三：

有时候需要在窗口上使用一些控件，比如IE，当你的窗口改变大小的时候IE会闪烁，即使你有了WS_CLIPCHILDREN
也没用。原因在于窗口的类风格有CS_HREDRAW 或者 CS_VREDRAW，这两个风格表示窗口在宽度或者高度变化的时候
重画，但是这样就会引起IE闪烁

解决方法：注册窗口类的时候不要使用这两个风格，如果窗口需要在改变大小的时候重画，那么可以在WM_SIZE的时候
调用RedrawWindow。

原因四：

界面上窗口很多，而且改变大小时很多窗口都要移动和改变大小，如果使用MoveWindow或者SetWindowPos两个API来
改变窗口的大小和位置，由于他们是等待窗口重画完成后才返回，所以过程很慢，这样视觉效果就可能会闪烁。

解决方法：

使用以下API来处理窗口移动，BeginDeferWindowPos, DeferWindowPos，EndDeferWindowPos
先调用 BeginDeferWindowPos 设定需要移动的窗口的个数
使用DeferWindowPos，来移动窗口，这个API并不真的造成窗口移动
EndDeferWindowPos 一次性完成所有窗口的大小和位置的改变。

有个地方要特别注意，要仔细计算清楚要移动多少个窗口，BeginDeferWindowPos设定
的个数一定要和实际的个数一致，否则在Win9x下，如果实际移动的窗口数多于调用BeginDeferWindowPos
时设定的个数，可能会造成系统崩溃。在Windows NT系列下不会有这样的问题。

*******************************

使用内存DC解决重画闪烁问题

 
下述代码在OnDraw时绘图：

void CRedrawDemoView::OnDraw(CDC* pDC)

{

       CRedrawDemoDoc* pDoc = GetDocument();

       ASSERT_VALID(pDoc);

       // TODO: add draw code for native data here

       static const char* pText = "解决重画闪烁问题！";

       RECT clRect;

       ::GetClientRect(m_hWnd, &clRect);

       pDC->FillSolidRect(&clRect, RGB(255, 255, 255));

       int x = 100, y = 100;

       RECT rect = { x - 20, y - 20};

       rect.right = rect.left + 160;

       rect.bottom = rect.top + 60;

       pDC->FillSolidRect(&rect, RGB(0, 255, 0));

       pDC->TextOut(x, y, pText, strlen(pText));

}

首先将背景填充白色，然后画一绿色的矩形，再在矩形上输出一段文字，如此过程必然会引起画面闪烁，
解决办法：使用内存DC，先将图形绘制到内存DC，然后拷贝到屏幕，实现无闪烁绘图。
修改后的代码如下：

void CRedrawDemoView::OnDraw(CDC* pDC)

{

       CRedrawDemoDoc* pDoc = GetDocument();

       ASSERT_VALID(pDoc);

       // TODO: add draw code for native data here

       static const char* pText = "解决重画闪烁问题！";

       CRect clRect;

       ::GetClientRect(m_hWnd, &clRect);

       CDC memDC;

       memDC.CreateCompatibleDC(pDC);

       CBitmap bitmap;

       bitmap.CreateCompatibleBitmap(pDC, clRect.Width(), clRect.Height());

       CBitmap * pOldBitmap = memDC.SelectObject(&bitmap);

       memDC.FillSolidRect(&clRect, RGB(255, 255, 255));

       int x = 100, y = 100;

       RECT rect = { x - 20, y - 20};

       rect.right = rect.left + 160;

       rect.bottom = rect.top + 60;

       memDC.FillSolidRect(&rect, RGB(0, 255, 0));

       memDC.TextOut(x, y, pText, strlen(pText));

       pDC->BitBlt(0, 0, clRect.Width(), clRect.Height(), &memDC, 0, 0, SRCCOPY);

       memDC.SelectObject(pOldBitmap);

}

也可以在上述代码中加入绘制Bitmap位图代码，注意应该阻止窗口擦除背景，重载OnEraseBkgnd函数

BOOL CRedrawDemoView::OnEraseBkgnd(CDC* pDC)

{

       // TODO: Add your message handler code here and/or call default

       return TRUE;

       // return CView::OnEraseBkgnd(pDC);

}

为易于理解，以上代码未经优化。

类成员方法是一个比较特殊的函数，它在编译时会被转化成普通函数，比如有TMyClass类:
class TMyClass{
    void Func();
};

这个TMyClass::Func最终会转化成 void Func(TMyClass *this); 也就是说在原第一个参数前插入指向对象本身的this指针。

我们可以利用这个特性写一个非静态类成员方法来直接作为线程回调函数，先看_beginthread函数的定义:
unsigned long _RTLENTRY _EXPFUNC _beginthread (void (_USERENTRY *__start)(void *),unsigned __stksize, void *__arg);
其中的第一个参数就是作为线程执行主体的回调函数。它的原型是:void Func(void *)，这个void*参数是作为自定义数据传入的。对比一下上面所说的TMyClass::Func的最终形式，它正好可以符合这里的要求。

现在做个实验:
#include <stdio.h>
#include <process.h>

class TMyClass{
    int m_nCount;
    int m_nId;
public:
    TMyClass(int nId,int nCount)
        :m_nId(nId),m_nCount(nCount)
    {
    }

    void _USERENTRY ThreadProc()            // 类成员方法
    {
        for(int i=0; i<m_nCount; i++)       // 根据m_nCount成员打印一排数字
        {
            printf("Class%d : %d\n",m_nId,i);
        }
    }
};

int main(int argc, char* argv[])
{
    union {                                // 联合类，用于转换类成员方法指针到普通函数指针（试过编译器不允许在这两种函数之间强制转换），不知道有没有更好的方法。
        void (_USERENTRY *ThreadProc)(void *);
        void (_USERENTRY TMyClass::*MemberProc)();
    } Proc;                                // 尽管联合里的两种函数类型现在看起来有很大不同，但它们的最终形式是相同的。

    TMyClass MyClass1(1,10),MyClass2(2,5); // 产生两个TMyClass对象

    Proc.MemberProc = &TMyClass::ThreadProc;   // 转换，Proc.ThreadProc就是对应的普通函数指针了

    _beginthread(Proc.ThreadProc,4096,&MyClass1);   // 开始线程，这里的Proc.ThreadProc实际上是TMyClass::ThreadProc, 它要的this指针是我们给的&MyClass1。
    _beginthread(Proc.ThreadProc,4096,&MyClass2);
    system("pause");
    return 0;
}

运行！神奇吧？:-)

其实不止线程回调函数，其实只要是形如Func(void*,...)的回调函数都可以用这种方法直接使用类成员方法。(前提是第一个void*是自定义数据，也就是说它不能有其它功能)。

转自:http://blog.csdn.net/waiting4you/archive/2007/12/29/2000796.aspx

GetDc函数：用于获得hWnd参数所指定窗口的客户区域的一个设备环境。

所获得的设备环境可以是通用、类或者私有类型，具体由指定窗口的类风格决定。对于通用设备环境，GetDc函数每次获取一个设备环境时都会用默认属性对它进行初始化。该函数获得的类和私有设备环境会与它们最后一次的设置保持一致。当设备环境不再需要时，应该调用ReleaseDC函数将其释放。   
    
GetWindowDC函数：返回hWnd参数所指定的窗口的设备环境。

获得的设备环境覆盖了整个窗口（包括非客户区），例如标题栏、菜单、滚动条，以及边框。这使得程序能够在非客户区域实现自定义图形，例如自定义标题或者边框。当不再需要该设备环境时，需要调用ReleaseDC函数释放设备环境。注意，该函数只获得通用设备环境，该设备环境的任何属性改变都不会反映到窗口的私有或者类设备环境中（如果窗口有的话）   
    
   ----------摘自《Delphi    Win32核心API参考》

=============================================================

BOOL   GetItemPosition(int   nItem,LPPOINT   lpPoint)   const

返回值：如果成功，则返回非零值，否则为0。

参数：   nItem   要获取位置的项的索引值。    
lpPoint   在视图坐标中接受项左上角位置POINT结构的地址，按视图坐标。    

说明：获取列表视图项的位置。
//////////////////////////////////////////////////////////////
CListCtrl::GetItemRect

BOOL   GetItemRect(int   nItem,LPRECT   lpRect,UNIT   nCode)   const

返回值：如果成功，则返回非零值，否则为0。

参数：   nItem   要获取位置的项的索引值。    
lpRect   接受绑定矩形的RECT结构的地址。    
nCode   要获取绑定矩形的列表视图项的部分。它可为下列值之一：   ·   LVIR_BOUNDS   返回整个项的绑定矩形，包括图标和标签。    
·   LVIR_ICON   返回图标或小图标的绑定矩形。    
·   LVIR_LABEL   返回项文本的绑定矩形。    
 

说明：
在当前视图中获取某项的全部或部分的绑定矩形。

获得CMainFrame:
 -在CMinApp中用AfxGetMainWnd()或者m_pMainWnd
 -在CChildFrame中可用GetParentFrame()
 -在其它类中用AfxGetMainWnd()

获得CChildFrame:
 -在CView中用GetParentFrame()
 -在CMainFrame中用MDIGetActive()或GetActiveFrame()
 -在其它类中用AfxGetMainWnd()->MDIGetActive()或AfxGetMainWnd()->GetActiveFrame()

获得CDocument:
 -在CView中用GetDocument()
 -在CChildFrame中用GetActiveView()->GetDocument()
 -在CMainFrame中用
  -if SDI:GetActiveView()->GetDocument()
  -if MDI:MDIGetActive()->GetActiveView()->GetDocument()
 -在其它类中
  -if SDI:AfxGetMainWnd()->GetActiveView()->GetDocument()
  -if MDI:AfxGetMainWnd()->MDIGetActive()->GetActiveView()->GetDocument()

获得CView:
 -在CDocument中 POSITION pos = GetFirstViewPosition();GetNextView(pos)
 -在CChildFrame中 GetActiveView()
 -在CMainFrame中
  -if SDI:GetActiveView()
  -if MDI:MDIGetActive()->GetActiveView()
 -在其它类中
  -if SDI:AfxGetMainWnd()->GetActiveView()
  -if MDI:AfxGetMainWnd()->MDIGetActive()->GetActiveView()

不过要注意在doc中要取得view的指针C*View要注意类C*View声明的问题,
因为默认情况下,mfc在*View.h中已经包含了*Doc.h,如果在*Doc.h中包含
*View.h,就会引起嵌套包含问题,这样要在*Doc.h中加入 class C*View;
而在*Doc.cpp中加入 #include "*View.h"

//////////////////////////////////////////////////////////////////
其实完全可以在CYourApp中添加各种视或文档的指针，在那些视或文档初
始化的时候将指针传给CYourApp中的对应变量，这样以后不管在哪用上面
指针只需(CYourApp*)AfxGetApp()取其属性变量即可，明了而且清楚更是
方便我一直专门操作的说：）

//////////////////////////////////////////////////////////////////
我先抛块砖，有玉的砸过来！
在何时何地，你都可以通过以下方法精确的得到任何一个对象（Application，DocTemplate,Document，View,Frame）
1。通过AfxGetApp()得到当前的App对象；
2。通过AfxGetMainWnd（）得到主窗口；
3。通过CMDIFrameWnd::GetActiveFrame得到当前活动窗口；
4。通过GetNextWindow()遍例所有的子窗口；（如果要得到你想要的子窗口，可以通过特定的成员变量来标志）；
5。通过CWinApp::GetFirstDocTemplatePostion()以及CWinApp::GetNextDocTemplate()的组合应用来遍历所有的DocTemplate对象，并且用CDocTemplate::GetDocString()来判断当前得到的文档莫板对象是哪个。
6。通过CDocTemplate::GetFirstDocPosition()以及CDocTemplate的GetNextDoc（）组合来遍历所有的该模板的文档对象，并用CDocument::GetDocTemplate()来得到文档模板，用CDocment::GetTitle() 或者GetPathName()来判断当前的文档是哪个。
7。通过CDocuemt的GetFirstViewPositon()以及GetNextView()来遍历视图对象，一般通过访问View的成员变量来区别各个视图；通过CView::GetDocument()来得到文档对象；
8。Frame->View： 通过GetActiveView方法；
9。Frame->Doc：通过GetActiveDocument();
10。View->Frame：GetParentFrame();
11。View->Doc:GetDocuemt()//前面已经说了。
12。Doc->View:前面说了；
13。Doc->Frame:不知道有没有很直接的方法。
MFC应用程序中指针的使用

1) 在View中获得Doc指针
2) 在App中获得MainFrame指针
3) 在View中获得MainFrame指针
4) 获得View（已建立）指针
5) 获得当前文档指针
6) 获得状态栏与工具栏指针
7) 获得状态栏与工具栏变量
8) 在Mainframe获得菜单指针
9) 在任何类中获得应用程序类
10) 从文档类取得视图类的指针(1)
11) 在App中获得文档模板指针
12) 从文档模板获得文档类指针
13) 在文档类中获得文档模板指针
14) 从文档类取得视图类的指针(2)
15) 从一个视图类取得另一视图类的指针

VC中编程对于刚刚开始学习的同学，最大的障碍和问题就是消息机制和指针获取与
操作。其实这些内容基本上是每本VC学习工具书上必讲的内容，而且通过MSDN很多
问题都能解决。下面文字主要是个人在编程中指针使用的一些体会，说的不当的地
方请指正。一般我们使用的框架是VC提供的Wizard生成的MFC App Wizard(exe)框架，
无论是多文档还是单文档，都存在指针获取和操作问题。下面这节内容主要是一般
的框架，然后再讲多线程中的指针使用。使用到的类需要包含响应的头文件。首先
一般获得本类(视，文档，对话框都支持)实例指针this，用this的目的，主要可以通
过类中的函数向其他类或者函数中发指针，以便于在非本类中操作和使用本类中的
功能。

 1） 在View中获得Doc指针 CYouSDIDoc *pDoc=GetDocument();一个视只能有一个文
档。
 2) 在App中获得MainFrame指针
CWinApp 中的 m_pMainWnd变量就是MainFrame的指针
也可以： CMainFrame *pMain =(CMainFrame *)AfxGetMainWnd();
 3) 在View中获得MainFrame指针 CMainFrame *pMain=(CmaimFrame *)AfxGetApp()->m_pMainWnd;
 4) 获得View（已建立）指针 CMainFrame *pMain=(CmaimFrame *)AfxGetApp()->m_pMainWnd;
CyouView *pView=(CyouView *)pMain->GetActiveView();
 5) 获得当前文档指针 CDocument * pCurrentDoc =(CFrameWnd *)m_pMainWnd->GetActiveDocument();
 6) 获得状态栏与工具栏指针 CStatusBar * pStatusBar＝(CStatusBar *)AfxGetMainWnd()->GetDescendantWindow(AFX_IDW_STATUS_BAR);
CToolBar * pToolBar=(CtoolBar *)AfxGetMainWnd()->GetDescendantWindow(AFX_IDW_TOOLBAR);

 7) 如果框架中加入工具栏和状态栏变量还可以这样
(CMainFrame *)GetParent()->m_wndToolBar;
(CMainFrame *)GetParent()->m_wndStatusBar;

 8) 在Mainframe获得菜单指针 CMenu *pMenu=m_pMainWnd->GetMenu();
 9) 在任何类中获得应用程序类
用MFC全局函数AfxGetApp()获得。

 10) 从文档类取得视图类的指针
我是从http://download.cqcnc.com/soft/program/article/vc/vc405.html学到的，
从文档获得视图类指针目的一般为了控制同一文档的多个视图的定位问题，我的体会
特别是文字处理CEditView当产生多个视图类时，这个功能是非常需要的。
CDocument类提供了两个函数用于视图类的定位：
GetFirstViewPosition()和GetNextView()
virtual POSITION GetFirstViewPosition() const;
virtual CView* GetNextView(POSITION& rPosition) const;

注意：GetNextView()括号中的参数用的是引用方式，因此执行后值可能改变。
GetFirstViewPosition()用于返回第一个视图位置（返回的并非视图类指针，而是一
个POSITION类型值），GetNextView()有两个功能：返回下一个视图类的指针以及用
引用调用的方式来改变传入的POSITION类型参数的值。很明显，在Test程序中，只有
一个视图类，因此只需将这两个函数调用一次即可得到CTestView的指针如下（需定
义一个POSITION结构变量来辅助操作）：
CTestView* pTestView;
POSITION pos=GetFirstViewPosition();
pTestView=GetNextView(pos);

这样，便可到了CTestView类的指针pTestView.执行完几句后，变量pos=NULL,因为没
有下一个视图类，自然也没有下一个视图类的POSITION.但是这几条语句太简单，不
具有太强的通用性和安全特征；当象前面说的那样，当要在多个视图为中返回某个指
定类的指针时，我们需要遍历所有视图类，直到找到指定类为止。判断一个类指针指
向的是否某个类的实例时，可用IsKindOf()成员函数时行检查，如：
 pView->IsKindOf(RUNTIME_CLASS(CTestView));
即可检查pView所指是否是CTestView类。

有了以上基础，我们已经可以从文档类取得任何类的指针。为了方便，我们将其作
为一个文档类的成员函数，它有一个参数，表示要获得哪个类的指针。实现如下：
CView* CTestDoc::GetView(CRuntimeClass* pClass)
{
 CView* pView;
 POSITION pos=GetFirstViewPosition();

 while(pos!=NULL){
  pView=GetNextView(pos);
  if(!pView->IsKindOf(pClass))
  break;
 }

 if(!pView->IsKindOf(pClass)){
  AfxMessageBox("Connt Locate the View.\r\n http://www.VCKBASE.com");
  return NULL;
 }

 return pView;
}

其中用了两次视图类的成员函数IsKindOf()来判断，是因为退出while循环有三种
可能：

1.pos为NULL，即已经不存在下一个视图类供操作；
2.pView已符合要求。

1和2同是满足。这是因为GetNextView()的功能是将当前视图指针改变成一个视图
的位置同时返回当前视图指针，因此pos是pView的下一个视图类的POSITION,完全
有可能既是pos==NULL又是pView符合需要。当所需的视图是最后一个视图是最后一
个视图类时就如引。因此需采用两次判断。
使用该函数应遵循如下格式（以取得CTestView指针为例）：
CTestView* pTestView=(CTestView*)GetView(RUNTIME_CLASS(CTestView));
RUNTIME_CLASS是一个宏，可以简单地理解它的作用：将类的名字转化为
CRuntimeClass为指针。至于强制类型转换也是为了安全特性考虑的，因为从同一个
基类之间的指针类型是互相兼容的。这种强制类型转换也许并不必要，但能避免一
些可能出现的麻烦。

3.从一个视图类取得另一视图类的指针综合1和2，很容易得出视图类之间互相获得
指针的方法：就是用文档类作中转，先用1的方法得到文档类的指针，再用2的方法，
以文档类的视图定位函数取得另一个视图类。同样，可以实现成一个函数：
（假设要从CTestAView中取得指向其它视图类的指针）
CView* CTestAView::GetView(CRuntimeClass* pClass)
{
 CTestDoc* pDoc=(CTestDoc*)GetDocument();
 CView* pView;
 POSITION pos=pDoc->GetFirstViewPosition();
 while(pos!=NULL){
  pView=pDoc->GetNextView(pos);
  if(!pView->IsKindOf(pClass))
  break;
 }
 if(!pView->IsKindOf(pClass)){
  AfxMessageBox("Connt Locate the View.");
  return NULL;
 }

 return pView;
}
这个函数和2中的GetView()相比，一是多了第一句以取得文档类指针，二是在
GetFirstViewPosition()和GetNextView()前加上了文档类指针，以表示它们是文档
类成员函数。有了此函数；当要从CTestAView中取得CTestBView的指针时，只需如
下：CTestBView* pTestbView=(CTestView*)GetView(RUNTIME_CLASS(CTestBView));
11）对于单文档中也可以加入多个文档模板，但是一般的开发就使用MDI方式开发
多文档模板，其方法与上述视图的获取方法很接近，这里稍做解释，如果不清楚，
请查阅MSDN，（以下四个内容（11、12、13、14）来源：
http://sanjianxia.myrice.com/vc/vc45.htm）

可以用CWinApp::GetFirstDocTemplatePostion获得应用程序注册的第一个文档模板
的位置；利用该值来调用CWinApp::GetNextDocTemplate函数，获得第一个
CDocTemplate对象指针。 POSITION GetFirstDocTemplate( ) const;
CDocTemplate *GetNextDocTemplate( POSITION & pos ) const;

第二个函数返回由pos 标识的文档模板。POSITION是MFC定义的一个用于迭代或对象
指针检索的值。通过这两个函数，应用程序可以遍历整个文档模板列表。如果被检索
的文档模板是模板列表中的最后一个，则pos参数被置为NULL。

 12）一个文档模板可以有多个文档，每个文档模板都保留并维护了一个所有对应文
档的指针列表。
用CDocTemplate::GetFirstDocPosition函数获得与文档模板相关的文档集合中第一
个文档的位置，并用POSITION值作为CDocTemplate::GetNextDoc的参数来重复遍历与
模板相关的文档列表。函数原形为：
viaual POSITION GetFirstDocPosition( ) const = 0;
visual CDocument *GetNextDoc(POSITION & rPos) const = 0; 

如果列表为空，则rPos被置为NULL.

 13）在文档中可以调用CDocument::GetDocTemplate获得指向该文档模板的指针。
函数原形如下： CDocTemplate * GetDocTemplate ( ) const;
如果该文档不属于文档模板管理，则返回值为NULL。

 14)一个文档可以有多个视。每一个文档都保留并维护一个所有相关视的列表。
CDocument::AddView将一个视连接到文档上，将该视加入到文档相联系的视的列表
中，并将视的文档指针指向该文档。当有File/New、File/Open、Windows/New或
Window/Split的命令而将一个新创建的视的对象连接到文档上时， MFC会自动调用
该函数，框架通过文档/视的结构将文档和视联系起来。当然，程序员也可以根据自
己的需要调用该函数。
Virtual POSITION GetFirstViewPosition( ) const;
Virtual CView * GetNextView( POSITION &rPosition) cosnt;

应用程序可以调用CDocument::GetFirstViewPosition返回与调用文档相联系的视的
列表中的第一个视的位置，并调用CDocument::GetNextView返回指定位置的视，并将
rPositon的值置为列表中下一个视的POSITION值。如果找到的视为列表中的最后一个
视，则将rPosition置为NULL.

 15)从一个视图类取得另一视图类的指针
这个应用在多视的应用程序中很多见，一般如果自己在主程序或者主框架中做好变
量记号，也可以获得，还有比较通用的就是用文档类作中转，以文档类的视图遍历
定位，取得另一个视图类。这个功能从本文第10项中可以得到。

1。先来介绍REPORT类型的CListCtrl：
首先使用下面的语句设置CListCtrl的style：
 DWORD SetExtendedStyle( DWORD dwNewStyle );
其中
 LVS_EX_CHECKBOXES 表示添加CheckBox
 LVS_EX_FULLROWSELECT 表示选择整行
 LVS_EX_GRIDLINES 表示添加表格线

如果设置了LVS_EX_CHECKBOXES属性，则可以用
 BOOL GetCheck( int nItem ) const;
来得到某一行是否Checked。

可以先用下面的语句来删除以前的东西：
 for(int k=2;k>=0;k--) //注意要从后往前删，否则出错
  m_ListCtrl.DeleteColumn(k);
 m_ListCtrl.DeleteAllItems();

用下面的语句新建列：
 m_ListCtrl.InsertColumn(0,_T("文件名"),LVCFMT_IMAGE|LVCFMT_LEFT);
 m_ListCtrl.InsertColumn(1,_T("仪器类别"));
 m_ListCtrl.InsertColumn(2,_T("项目类别"));
 
其中LVCFMT_IMAGE表示可以在第一列加入图标。如果不要图标可以删去。

然后设置列宽：
 for(j=0;j<3;j++)
  m_ListCtrl.SetColumnWidth(j ,100);
 
以下为列表加入图标，如果不需要图标，可以跳过这一步。注意只在第一次加入，如果多次加入会出错！
先在头文件中加入声明：
 CImageList m_ImageList;
这是必要的，如果在cpp的某个函数中加入由于生命期结束，CImageList自动释放，则效果是列表中看不到图标，只看到一个白方块。
下面生成CImageList，并将其绑定到CListCtrl中，这是CImageList中还没有图标，只是一个容器：
 static int flag=2;
 if(flag==2){//只调用一次SetImageList，否则出错
  m_ImageList.Create(128, 128, ILC_COLORDDB|ILC_MASK, 20, 1); 
  m_ListCtrl.SetImageList(&m_ImageList,LVSIL_SMALL);
 }
 flag=(flag+1)%2;
如果CListCtrl已经用过，曾经加过图标进去，这时就要删除上次放进m_ImageList中的Image
 for(int kk=0;kk<m_ImageList.GetImageCount();kk++)
  m_ImageList.Remove(k);
 
下面介绍如何向CListCtrl里面加入行，并同时为每一行动态加入图标：
假设m_listRowCount为要加入的行数。
 CBitmap* bitmap;
 bitmap=new CBitmap[m_list1rowCount];
 HBITMAP hbitmap; 
 
 for(int i = 0; i < m_listRowCount; i++)
 {
  //为每一行插入相应的缩略图
  CFile f;
  CFileException e;  
  if( !f.Open(m_FileName, CFile::modeRead, &e )){ //m_FileName为bmp文件名，由你来定
   hbitmap = (HBITMAP)LoadImage(NULL,path+"blank.bmp",IMAGE_BITMAP,0,0,
    LR_CREATEDIBSECTION|LR_DEFAULTSIZE|LR_LOADFROMFILE);
  }else{
   f.Close();
   hbitmap = (HBITMAP)LoadImage(NULL,bmpFile,IMAGE_BITMAP,0,0,
    LR_CREATEDIBSECTION|LR_DEFAULTSIZE|LR_LOADFROMFILE);
  }
  bitmap[i].Attach(hbitmap);
  m_ImageList.Add(&bitmap[i], RGB(0, 128, 128));
  
  //插入行
  m_ListCtrl.InsertItem(i,m_FileName,i);
  m_ListCtrl.SetItemText(i,1,type);
  m_ListCtrl.SetItemText(i,2,m_Path);
 }
  
 //记得删除已经没用的临时文件
 if(m_list1rowCount!=0)
  delete[] bitmap;

2。如果是ICON类型的CListCtrl，则要做一点点改动：
把绑定图标集的代码由
 SetImageList(&m_ImageList,LVSIL_SMALL);
改为
 SetImageList(&m_ImageList,LVSIL_NORMAL);

插入行时只用
 InsertItem(i,mainSet.m_FileName,i);
不用