//在重绘消息WM_PAINT被发送时执行：
void CSampleView::OnDraw(CDC* pDC)
{
	CTSampleDoc* pDoc = GetDocument();
	ASSERT_VALID(pDoc);

//OPENGL前序工作顺利完成时，设置此标志为TRUE
	if (!m_bAppIsActive)
		return;

	RenderAll();//全部的渲染代码

	SwapBuffers(m_hDC);//双缓冲交换

	Invalidate(FALSE); //发送WM_PAINT
}

BOOL CMainFrame::OnCreateClient(LPCREATESTRUCT lpcs, CCreateContext* pContext) 
{
	if (!m_wndSplitter.CreateStatic(this, 1, 2))    
      return FALSE; 

  if (!m_wndSplitter.CreateView(0, 0, RUNTIME_CLASS(CLeftView), CSize(224, 600), pContext) 
    || !m_wndSplitter.CreateView(0, 1, RUNTIME_CLASS(CRightView), CSize(800, 600), pContext)) 
	{               
	   m_wndSplitter.DestroyWindow(); 
	   return FALSE; 
	} 
	return TRUE; 
	
//	return CFrameWnd::OnCreateClient(lpcs, pContext);
}

class CLeftView;
class CRightView : public CView
{
..................
	CLeftView  *MyTreeView;
};

bool CRightView ::ConnectTreeView()
{
	CMainFrame *MyMainFrame = (CMainFrame *)AfxGetApp()->m_pMainWnd;
	if(!MyMainFrame)return false;

	MyTreeView = (CLeftView  *)MyMainFrame->m_wndSplitter.GetPane(0,0);
	if(!MyTreeView)return false;

	return true;
}

LRESULT CALLBACK DLGPROC(HWND hdlg, UINT msg, WPARAM wparam, LPARAM lparam)
{
 switch(msg)
{
  ........
     case WM_COMMAND
     {
        if(HIWORD(wparam) == STN_CLICKED && LOWORD(wparam) == IDC_GSTATIC)
		   { 
		   onMouseDown = true;
		   GetCursorPos(&OriMousePt);
		   ScreenToClient(StaticWND,&OriMousePt);
		    ...........
		    }
  .........
     }
}

return false;
}

WNDPROC ParentGPROC = NULL;
LRESULT CALLBACK SUBGPROC(HWND subhwnd, UINT msg, WPARAM wparam, LPARAM lparam);

LRESULT CALLBACK DLGPROC(HWND hdlg, UINT msg, WPARAM wparam, LPARAM lparam) 
{ 
 switch(msg) 
{ 
        case WM_INITDIALOG: 
         .........
       SubGPROC = (WNDPROC)SetWindowLong(StaticWND, GWL_WNDPROC, (LONG)SUBGPROC);
        .........
       break;

  ........ 
     case WM_COMMAND 
     { 
        if(HIWORD(wparam) == STN_CLICKED && LOWORD(wparam) == IDC_GSTATIC) 
           {  
           onMouseDown = true; 
           GetCursorPos(&OriMousePt); 
           ScreenToClient(StaticWND,&OriMousePt); 
            ........... 
            } 
  ......... 
     } 
   break;
} 

return false; 
}

LRESULT CALLBACK SUBGPROC(HWND subhwnd, UINT msg, WPARAM wparam, LPARAM lparam)
{
	switch(msg)
	{
	case WM_PAINT:
          	SThdc = BeginPaint(StaticWND, &ps);
  				
	..............

			EndPaint(StaticWND, &ps);
			return 0;
	break;
	

	case WM_LBUTTONDOWN:
        onMouseDown = true;	
		GetCursorPos(&OriMousePt);
		ScreenToClient(subhwnd,&OriMousePt);
		.........
	break;
	case WM_LBUTTONUP:
		onMouseDown = false;
	break;
	case WM_MOUSEMOVE:
		if(onMouseDown)
		{
			POINT MosuePos;
			GetCursorPos(&MosuePos);
			ScreenToClient(subhwnd,&MosuePos);
	    	..............
				 InvalidateRect(StaticWND,NULL,TRUE);
		}
	break;
	default:
		return CallWindowProc(ParentGPROC ,subhwnd, msg, wparam, lparam);
	}
	

	return 0;
}

			        long currentWindowLong = GetWindowLong(hwnd, GWL_EXSTYLE);
                    SetWindowLong(hwnd, GWL_EXSTYLE, currentWindowLong | WS_EX_LAYERED);	
	                SetLayeredWindowAttributes(hwnd, 0, 255 * 70/100, 0x2);

		             long currentWindowLong = GetWindowLong(hwnd, GWL_EXSTYLE);
                     SetWindowLong(hwnd, GWL_EXSTYLE, currentWindowLong & ~WS_EX_LAYERED);

typedef BOOL (WINAPI * TRANSFUNC)(HWND hwnd, COLORREF crKey, BYTE bAlpha, DWORD dwFlags);
TRANSFUNC SetLayeredWindowAttributes;

#define WS_EX_LAYERED 0x00080000

void LoadTransparenceModule()
{
	HMODULE trModule = GetModuleHandle("User32.dll");
	SetLayeredWindowAttributes = (TRANSFUNC)GetProcAddress(trModule, "SetLayeredWindowAttributes");

}

	case WM_MOUSEMOVE:
		{
			RECT MyRect;
			GetClientRect(hwnd, &MyRect);

			POINT mousept;
			mousept.x = LOWORD(lparam);
			mousept.y = HIWORD(lparam);

			if(!PtInRect(&MyRect,mousept))
			{
			    long currentWindowLong = GetWindowLong(hwnd, GWL_EXSTYLE);
				SetWindowLong(hwnd, GWL_EXSTYLE, currentWindowLong | WS_EX_LAYERED);	
	            SetLayeredWindowAttributes(hwnd, 0, 255 * 70/100, 0x2);
			}
			else{
		    	long currentWindowLong = GetWindowLong(hwnd, GWL_EXSTYLE);
                SetWindowLong(hwnd, GWL_EXSTYLE, currentWindowLong & ~WS_EX_LAYERED);
			
			}
         
		}
	break;

	case WM_NCHITTEST:
		{
			RECT MyRect;
			GetClientRect(hwnd, &MyRect);

			POINT mousept;
			mousept.x = LOWORD(lparam);
			mousept.y = HIWORD(lparam);

			ScreenToClient(hwnd, &mousept);

			if(!PtInRect(&MyRect,mousept))
			{
			    long currentWindowLong = GetWindowLong(hwnd, GWL_EXSTYLE);
				SetWindowLong(hwnd, GWL_EXSTYLE, currentWindowLong | WS_EX_LAYERED);	
	            SetLayeredWindowAttributes(hwnd, 0, 255 * 70/100, 0x2);
			}
			else{
				SetCapture(hwnd);
		    	long currentWindowLong = GetWindowLong(hwnd, GWL_EXSTYLE);
                SetWindowLong(hwnd, GWL_EXSTYLE, currentWindowLong & ~WS_EX_LAYERED);
			
			}
		}
	break;

	case WM_MOUSEMOVE:
		{

			if(!mouseTrack)
			{
				TRACKMOUSEEVENT mouseevent;
				mouseevent.cbSize = sizeof(TRACKMOUSEEVENT);
				mouseevent.dwFlags = TME_LEAVE;
				mouseevent.hwndTrack = hwnd;

				if( TrackMouseEvent(&mouseevent) )
				{
					mouseTrack = true;
					long currentWindowLong = GetWindowLong(hwnd, GWL_EXSTYLE);
                    SetWindowLong(hwnd, GWL_EXSTYLE, currentWindowLong & ~WS_EX_LAYERED);

					long currentWinStyle = GetWindowLong(hwnd, GWL_STYLE);
					SetWindowLong(hwnd, GWL_STYLE, currentWinStyle | WS_CAPTION);

				}
			}         
		}
	break;

	case WM_MOUSELEAVE:
		{
			RECT MyRect;
			GetClientRect(hwnd, &MyRect);

			POINT mousept;
			GetCursorPos(&mousept);

			ScreenToClient(hwnd, &mousept);

			if(!PtInRect(&MyRect,mousept))
			{
			long currentWindowLong = GetWindowLong(hwnd, GWL_EXSTYLE);
			SetWindowLong(hwnd, GWL_EXSTYLE, currentWindowLong | WS_EX_LAYERED);	
			SetLayeredWindowAttributes(hwnd, 0, 255 * 70/100, 0x2);
	
			long currentWinStyle = GetWindowLong(hwnd, GWL_STYLE);
			SetWindowLong(hwnd, GWL_STYLE, currentWinStyle &~ WS_CAPTION);

			}
			mouseTrack = false;
		}
	break;

  AllocConsole();
   freopen("CONOUT$","w+t",stdout); 
    freopen("CONIN$","r+t",stdin); 
    printf("hello\n");

				GetConsoleTitle(buffer,  80);   
				HWND  hwnd  =  FindWindow(NULL,  buffer);         
				HMENU hmenu =  GetSystemMenu(hwnd,  FALSE);         
				RemoveMenu(hmenu, SC_CLOSE,MF_BYCOMMAND);

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
<assemblyIdentity
  name="XP style manifest"
  processorArchitecture="x86"
  version="1.0.0.0"
  type="win32"/>
<dependency>
  <dependentAssembly>
    <assemblyIdentity
      type="win32"
      name="Microsoft.Windows.Common-Controls"
      version="6.0.0.0"
      processorArchitecture="x86"
      publicKeyToken="6595b64144ccf1df"
      language="*"
    />
  </dependentAssembly>
</dependency>
</assembly>

	 if(PeekMessage(&MyMessage, NULL, 0,0,PM_REMOVE))
	   {
		  if(MyMessage.message == WM_QUIT)break;

		   TranslateMessage(&MyMessage);
		   DispatchMessage(&MyMessage);
	   }

LRESULT CALLBACK WindowProc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)

CMainFrame::CMainFrame()   //构造函数
{
         ...................//这里对应，向导为我们设定了头文件中变量相应初始值，某些可在向导里更改，我一向用1024*768，depth：32

	// 开始渲染前问问是否需要全屏幕，MessageBox函数参数一目了然
	if (MessageBox("Would You Like To Run In Fullscreen Mode?", "Start FullScreen?",MB_YESNO|MB_ICONQUESTION)==IDYES)
	{          m_bFullScreen=TRUE;
	// 加自定义的变量初始值于此
}

CMainFrame::~CMainFrame()  //析构，调用KillGLWindow()
{	KillGLWindow();  }

//在建立一个窗口前，你总得做些什么。从第一行代码看会觉得它带来了CFrameWnd的一切。但是其实它们的本源还是 CWnd（重载于它）。窗口始终要被附加(attach)到一个CWnd对象上操作，CWnd会最终创建窗口
BOOL CMainFrame::PreCreateWindow(CREATESTRUCT& cs)
{
//CFrameWnd的PreCreateWindow究竟做了什么？太底层了我现在不想追查下去
	if (!CFrameWnd::PreCreateWindow(cs)) 
                                    return FALSE;

//EnumDisplaySettings获得当前显示驱动所支持的所有显示模式，这里是指渲染窗口未出现时我们的屏幕设置。存储到上文提到过的m_DMsaved中
//ChangeDisplaySettings则是相应的改变显示模式了（见稍下方）
	EnumDisplaySettings(NULL, ENUM_CURRENT_SETTINGS, &m_DMsaved);	
				
//全屏幕时候的设置：临时搭建一个DEVMODE对象并给予它“我们所定义的屏幕设置”的信息，把它的显示模式“拉伸”改变为全屏幕（注意，屏幕还是我自己设定那个1024*768*32，只是被“拉伸”了，事实上我自己屏幕就是1024*768，拉不拉没所谓，不过全屏下退出只有按ESC键了）
	if (m_bFullScreen)
	{
		DEVMODE dmScreenSettings;
		dmScreenSettings.dmPelsWidth	= VB_WIDTH;
		dmScreenSettings.dmPelsHeight	= VB_HEIGHT;
		dmScreenSettings.dmBitsPerPel	= VB_DEPTH;
		dmScreenSettings.dmFields=DM_BITSPERPEL|DM_PELSWIDTH|DM_PELSHEIGHT;

		if (ChangeDisplaySettings(&dmScreenSettings,CDS_FULLSCREEN)!=DISP_CHANGE_SUCCESSFUL)
		{  如果改变失败时执行的操作，无非是提示用户想不想退出程序之类，向导给我们做好了}
	}


	// 参入的CREATESTRUCT结构的cs，在CWnd中定义了创建函数创建窗口所用的初始参数（窗口风格），成员变量cx,cy就是窗口宽高了

	cs.cx = VB_WIDTH;
	cs.cy = VB_HEIGHT;

	if (m_bFullScreen)//全屏时还要加些样式
	{			
	cs.dwExStyle=WS_EX_APPWINDOW;//这个叫拓展样式,你查下,很傻B的	
	cs.style=WS_POPUP;//	猥琐(?)地弹出
	ShowCursor(FALSE);//隐藏鼠标
	}	
	else
	{	
	cs.dwExStyle=WS_EX_APPWINDOW | WS_EX_WINDOWEDGE;//突起边缘
	cs.style=WS_OVERLAPPEDWINDOW;//一个有标题栏的窗口,不猥琐

//cs.y和cs.x是新窗口的左上角Y,X坐标,GetSystemMetrics(SM_CYSCREEN)获得屏幕高,下面那个就是屏幕宽了.计算结果窗口就位于屏幕中心了
	cs.y = (int) GetSystemMetrics(SM_CYSCREEN) / 2 - cs.cy / 2; 
	cs.x = (int) GetSystemMetrics(SM_CXSCREEN) / 2 - cs.cx / 2;
	}
//LPCSTR变量lpszClass是新窗口的窗口类名,默认的CS_OWNDC说明窗口有自己的DC.另外里面还嵌套了个LoadCursor(第一参数是NULL,说明LOAD的系统光标I,DC_ARROW表示指针)
	cs.lpszClass = AfxRegisterWndClass(CS_OWNDC|CS_HREDRAW|CS_VREDRAW|CS_DBLCLKS,
		LoadCursor(NULL,IDC_ARROW), NULL, NULL);
	return TRUE;
}

#ifdef _DEBUG  
void CMainFrame::AssertValid() const //这些DEBUG函数在中篇说过了
        {CFrameWnd::AssertValid();}
void CMainFrame::Dump(CDumpContext& dc) const
        {CFrameWnd::Dump(dc);}
#endif //_DEBUG

BOOL CMainFrame::OnCreateClient(LPCREATESTRUCT lpcs, CCreateContext* pContext)
{
	// 我们先调用“真正的”OnCreateClient，成功了才来做我们的设置
	BOOL bRet = CFrameWnd::OnCreateClient(lpcs, pContext);
	if (bRet)
	{
		GLuint	PixelFormat; //用来存储所选择的像素信息

//PIXELFORMATDESCRIPTOR结构类型ptd描述了屏幕上所有像素的格式，可以说是一个描述器	
		static	PIXELFORMATDESCRIPTOR pfd=	 
		{
			sizeof(PIXELFORMATDESCRIPTOR),//这个描述器大小	
			1,			   //版本
//以下三项表明兼容性：这种像素格式要符合WINDOWS窗口，OPENGL	，双缓冲（可选）标准	
			PFD_DRAW_TO_WINDOW |	
			PFD_SUPPORT_OPENGL |	
			PFD_DOUBLEBUFFER,
		
			PFD_TYPE_RGBA,//颜色格式RGBA
			VB_DEPTH,            //颜色深度就用屏幕深度

//然后进行一些像素规格设置，有些也不知道是什么来的，我用原来向导给的英文注释标明防歧义
			0, 0, 0, 0, 0, 0,   //Color Bits Ignored		
			0,   //alpha通道缓冲，不设置		
			0,   // Shift Bit Ignored	
			0,   //累积缓冲，OPENGL五大缓存之一，需要时可启用
			0, 0, 0, 0,// Accumulation Bits Ignored
			16, //设置16位深度缓冲，五大缓存之一
			0, //蒙板缓冲，五大缓存之一，需要时可启用
			0, //辅助缓冲，五大缓存之一，需要时可启用
			PFD_MAIN_PLANE,// Main Drawing Layer(主绘图区)	
			0,	//保留		
			0, 0, 0	//Layer Masks Ignored	
		}; 
//注,五大缓存还有一个是颜色缓存(都设RGBA了,肯定有的,不然渲染窗口显示个啥)	
//下面就是像素设置了(注:以下{...}部分无非威胁我们设置不成功会如何如何(其实很必要的))

//先由Cwnd为我们获得DC,存入CMainframe的变量m_hDC 中:
	if ( !( m_hDC = ::GetDC ( m_hWnd ) ) ) {.......} 

//根据DC和刚才的像素描述器选择像素格式,返回像素格式索引号,存入刚才定义的PixelFormat 中
	if ( !( PixelFormat = ChoosePixelFormat ( m_hDC, &pfd ) ) )	{.......}

//根据DC,描述表和像素格式索引号设置像素格式:
	if ( !SetPixelFormat ( m_hDC, PixelFormat, &pfd ) {.......}


//下面是管理RC.先说一下用来管理RC的WGL函数(WGL – Windows的 OpenGL扩展层):
※ HGLRC wglCreateContext(HDC hdc)  //设置完像素格式后调用,根据DC创建一个RC
※BOOL wglMakeCurrent(HDC hdc, HGLRC hglrc) //关联DC和RC,让RC成为现行(激活)的
※HGLRC wglGetCurrentContext() //返回现行RC
※HDC wglGetCurrentDC() //返回与现行RC关联的那个DC
※BOOL wglDeleteContext(HGLRC hglrc) //删除一个RC(最好先让它变成非现行状态)
※BOOL wglUseFontBitmaps(HDC hdc, DWORD dwFirst, DWORD dwCount, DWORD dwBase) //这个用来根据DC创建字符显示列表

//下面需要用到最重要的第1,2个,至于第5个(删除)在后面退出时用:
		if ( !( m_hRC = wglCreateContext ( m_hDC ) ) ) {.......}
		if ( !wglMakeCurrent ( m_hDC, m_hRC ) ) {.......}

		if ( !InitGL () ) {.......}  //最后还要处理opengl的初始化

	m_bAppIsActive = TRUE;//以上全成功了,可以渲染了!
	}

	return bRet; //没错的话,现在可以打开窗口了
}

GLvoid CMainFrame::KillGLWindow(GLvoid)
{
//当前是全屏的话,首先检查一下未关闭前的这个屏幕设置能不能直接用到关闭后正常的那个屏幕上,可以的话就直接RESRT成那样就可以了;
//不行的话将当前设置变空,再把当初打开窗口前放进m_DMsaved(还记得么)的设置拿出来还给屏幕
	if (m_bFullScreen)		
	{
		if (!ChangeDisplaySettings(NULL,CDS_TEST)) {
			ChangeDisplaySettings(NULL,CDS_RESET);	
			ChangeDisplaySettings(&m_DMsaved,CDS_RESET);
		} else {
			ChangeDisplaySettings(NULL,CDS_RESET);
		}			
		ShowCursor(TRUE);
	}
//在有现行RC的情况下,关闭窗口的时候要delete它(delete前最好让它"非现行化")			
if ( m_hRC ) {
	if ( !wglMakeCurrent ( NULL, NULL ) ){....;}//省略的是出错提醒
	if ( !wglDeleteContext ( m_hRC ) ) {	.....;m_hRC = NULL;}		
	}
//最后删除DC,删除窗口
	if ( m_hDC && !::ReleaseDC ( m_hWnd, m_hDC ) ) {....;m_hDC = NULL;}
	if ( m_hWnd && !::DestroyWindow ( m_hWnd ) ){....;m_hDC = NULL;}	
}

void CMainFrame::RenderGLScene()
{
if (!m_bAppIsActive)return;//记得吗，m_bAppIsActive为真时才渲染
		
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);//清除背静			// Clear Screen And Depth Buffer
glLoadIdentity();//单位化

                      ........................
SwapBuffers(m_hDC);//更新缓存区
Invalidate(FALSE);  //拒绝无效化
}
//初始化和重置窗口大小，要使用时相关代码移到RenderGLScene开始部分
GLvoid CMainFrame::ReSizeGLScene(GLsizei width, GLsizei height){......}
//初始化程序，作OPENGL的预处理
int CMainFrame::InitGL(GLvoid){.....}

class CMainFrame : public CFrameWnd
{
	DECLARE_DYNAMIC(CMainFrame)

public:
	CMainFrame(); //构造函数
//Attributes
protected:
 //设备描述句柄DC(Device Context)和渲染描述句柄RC(Render Contex)，
//它们是OPENGL与操作系统，设备间交互所必不可少的。我将在下篇日志详细介绍
	HDC m_hDC;								
	HGLRC m_hRC;
							
//客户区长宽，我们平时不是可以手动调节渲染窗口的窗口大小吗？这种调节行为其实就是给程序发消息（还记得上篇日志中的PeekMessage么？）这两个参数会在OnSize()中保存调节后实际窗口的长宽，通过对应的消息响应ON_WM_SIZE()上交到消息队列，故暂停渲染来响应PeekMessage处理。
//所以平时我们调节窗口大小时可以看到渲染进程是暂停了的。
	UINT m_cxClient;
	UINT m_cyClient;

//调色板？貌似GDI+上见过类似类型名称的，不知道在这里用来干什么。搜索代码也只见在这里定义和初始化出现，实在迷糊。
	HPALETTE m_hPal;

//这个是我们屏幕大小 1024*768 起码最大化的时候要知道吧.
	int VB_WIDTH;
	int VB_HEIGHT;
//绘图深度
	int VB_DEPTH;

//DEVMODE的数据结构描述了要设定的显示器的各类属性值，刷新率啦分辨率啦
//OpenGL作图过程中有需要先保存起渲染前的这些屏幕数据，渲染完后返还
	DEVMODE	m_DMsaved;
//是否全屏幕				      
	BOOL m_bFullScreen;

// Operations
public:
	void RenderGLScene();//渲染函数
	BOOL m_bAppIsActive;//上篇日志提过，控制是否渲染
	GLvoid ReSizeGLScene(GLsizei width, GLsizei height);//重置窗口大小
	int InitGL(GLvoid);	//初始化
	GLvoid KillGLWindow(GLvoid);//关闭程序窗口
	void calculateFramesPerSec ();//计算FPS，非必要

// 重载来自父类的两个函数：
	virtual BOOL PreCreateWindow(CREATESTRUCT& cs); //初始化屏幕

//初始化像素设置，绘图设备（上面提到的DC，RC）等等
	virtual BOOL OnCreateClient(LPCREATESTRUCT lpcs, CCreateContext* pContext);
public:
	virtual ~CMainFrame();//析构

//同样重载（其实是调用父类的），用于DEBUG的函数
#ifdef _DEBUG       
 //AssertValid提供对对象内部状态的运行时检查，可用于验证成员函数有效值
	virtual void AssertValid() const;

//Dump函数将对象的成员变量的文本化表示形式写入转储上下文(CDumpContext，类似I/O流)
	virtual void Dump(CDumpContext& dc) const;
#endif

protected:
//{     又来了，消息映射表（MESSAGE_MAP，告诉MFC你要处理什么消息，在哪里），不过这次是“真”的了。
afx_msg void OnPaint();//对应消息ON_WM_PAINT()（以下类似）告诉窗口绘制自己
afx_msg void OnSize(UINT nType, int cx, int cy);//告诉窗口改变大小
afx_msg void OnSetFocus(CWnd *pOldWnd);//告诉窗口设立焦点

//当某一窗口即将激活时，主框架窗口将收到WM_QUERYNEWPALETTE消息，通知该窗口将要收到输入焦点，给它一次机会实现其自身的逻辑调色板； 
//当系统调色板改变后，主框架窗口将收到WM_PALETTECHANGED消息，通知其它窗口系统调色板已经改变，此时每一窗口都应该实现其逻辑调色板，重画客户区。
	afx_msg BOOL OnQueryNewPalette();
	afx_msg void OnPaletteChanged(CWnd* pFocusWnd);//告诉窗口绘制自己

//窗口被激活的时候触发，譬如你用另一个应用的窗口掩盖渲染穿口了
	afx_msg void OnActivateApp(BOOL bActive, HTASK hTask);
//按键消息
	afx_msg void OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags);
	//}}AFX_MSG
	DECLARE_MESSAGE_MAP()//（通过它程序找到以上对应的消息响应函数）
};

IMPLEMENT_DYNAMIC(CMainFrame, CFrameWnd)
//IMPLEMENT_DYNAMIC（参数为本类,本类的父类）与上面的DECLARE_DYNAMIC是两兄弟，不过它位于实现文件，打开：

//#define IMPLEMENT_DYNAMIC(class_name, base_class_name) \
//    IMPLEMENT_RUNTIMECLASS(class_name, base_class_name, 0xFFFF, NULL)

//就不再继续打开了，简单说明其作用：通过运行时在串行结构中为动态CObject派生类访问类名和位置来产生必要的C++代码（RTTI）。这就用到DECLARE_DYNAMIC获得的东西了
//其实一言毙之：就是在程序里搞RTTI的，MFC加了它们俩，没错的~（误）

BEGIN_MESSAGE_MAP(CMainFrame, CFrameWnd) //开始消息影射
	//{{       //这些就是窗口消息。与上面消息响应处理函数一一对应
	ON_WM_PAINT()
	ON_WM_SIZE()
	ON_WM_SETFOCUS()
	ON_WM_QUERYNEWPALETTE()
	ON_WM_PALETTECHANGED()
	ON_WM_ACTIVATEAPP()
	ON_WM_KEYDOWN()
	//}}
END_MESSAGE_MAP()//结束消息映射

//前面带空洪afx_msg的消息处理函数基本其实也是来自CWnd的,只是没有virtual符号而已(我不知道这算重写不,还是掩盖了,以后了解多点MFC再说).
void CMainFrame::OnPaint()//告诉窗口重绘自己
{
	CPaintDC dc(this);   //得到一个绘图用的DC
	// 加自己的东西(其实我都没加过 - -)	
//以下是CWnd的函数,用处是使窗口有效,并 清除消息队列中的WM_PAINT消息
	::ValidateRect ( m_hWnd, NULL );
}
void CMainFrame::OnSize(UINT, int cx, int cy)
{   //重新调整客户区域(窗口大小)时启动,ReSizeGLScene就是调整函数(见下篇)
	m_cxClient = cx;
	m_cyClient = cy;
	ReSizeGLScene( cx, cy );
}
//其实下面两个处理函数功用上面着重说过了,这里说说实现的问题
BOOL CMainFrame::OnQueryNewPalette()
{ //判断窗口是否即将要重绘(其实根本没判断,直接TRUE并重绘了 - -)
	Invalidate();
	return TRUE;
}
void CMainFrame::OnPaletteChanged(CWnd* pFocusWnd)
{ //注意只对主(顶)框架(top-level and overlapped windows)有效	
if ((pFocusWnd != this) && (!IsChild(pFocusWnd)))
		OnQueryNewPalette(); //重绘
}
void CMainFrame::OnSetFocus(CWnd* pOldWnd)
{  //窗口即将获得焦点时,重绘
	OnQueryNewPalette();
}
void CMainFrame::OnActivateApp(BOOL bActive, HTASK hTask)
{//调用上层OnActivateApp,bActive判断遮掩情况,然后赋予本地的判断变量m_bAppIsActive,m_bAppIsActive控制是否渲染
	CFrameWnd::OnActivateApp(bActive, hTask);
	m_bAppIsActive = bActive;
}
void CMainFrame::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags) 
{//同样调用上层函数,这里用switch控制按键
     CFrameWnd::OnKeyDown(nChar, nRepCnt, nFlags);
	switch ( nChar ) {
	case VK_ESCAPE:	
		PostMessage ( WM_CLOSE );
		break;
	} 	
}

#if _MSC_VER > 1000    //如果vc编译器的版本大于1000则...     
#pragma once
#endif // _MSC_VER > 1000

//关于#pragma once和#ifndef-#define-#endif的区别：
//1.前者指由编译器保证“某一个文件”（the same file）不会被包含多次
//（但是如果有多个"同名同内容的头文件"，那么它们就造成了重复包含，这时候应该用后者来避免）；
//2.后者指编译器保证"同一个名称的文件"(files with the same name)不会被包含多次
//（但是因为它是按名称来标识文件的，所以如果有多个“同名而不同内容的头文件“，其中一个就会被掩盖了）。
//所以，如果有两个同名的.h,(而不想或无法或忘记改名的时候,)如果内容不同,#pragma once; 相同,#ifndef

#ifndef __AFXWIN_H__
	#error include 'stdafx.h' before including this file for PCH
#endif
//这是要求所有源代码模块都包含预编译头文件（这样能够加快编译的速度），如果没包含就报错。

#include "resource.h"
 //资源文件和源代码文件的桥梁,伙同资源文件.rc,链成.res

class C***App : public CWinApp  //继承CWinApp, 控制整个应用程序
{   //运行程序要将该类实例化，并调用构造和重载的InitInstance()
  //因此事实上是透过CWinApp进入WinMain,WinMain对其InitInstance()
  //的控制导致C***App ::InitInstance()的自动执行,开始了一个应用程序实例的进程

public:       C***App();
private:
	LONGLONG   m_lCurTime;   //当前时间	
	DWORD	    m_dwTimeCount; //每帧的用时(没counter的时候就拿它作默认值)
	LONGLONG   m_lPerfCounter; // 定时器频率
	BOOL	    m_bPerFlag; // 选择器,决定哪个定时器起作用
	LONGLONG   m_lNextTime;// 渲染下一帧的时间
	LONGLONG   m_lLastTime;	// 当前帧(开始)的时间
	double	     m_dTimeElapsed;	// 自从当前帧开始到现在的时间
	double	     m_dTimeScale;	// 一个时间的乘数
	LONGLONG    m_lFramesPerSecond; // 程序运行时的FPS
// 重载的函数
public:
	virtual BOOL InitInstance();
	virtual int Run();   //这个很明显....run
public:         
    //这里留给编译器,谁也别动 (DO NOT EDIT HERE) 		       
	DECLARE_MESSAGE_MAP() //消息映射函数,关于它可可以延伸一下:
};
//MFC中提供了四个宏: 
//DECLARE_MESSAGE_MAP() :声明一些函数供接下来使用
//BEGIN_MESSAGE_MAP(子类,父类) :实现开始( 把消息函数的函数指针联系起来)
//ON_COMMAND    :定义具体的消息和消息对应的函数
//END_MESSAGE_MAP() : 实现结束.  你看下一篇接下来的实现就明白啦　　	

#ifdef   _DEBUG     //   判断是否定义_DEBUG，如果是，则：
#define  new    DEBUG_NEW     //   定义调试new宏，取代new关键字
//原来我们一直在用的new早被替换了呀~阴啊阴啊
//这个DEBUG_NEW可以在DEBUG状态下定位内存泄露并且跟踪文件名
//追踪它，发现 #define DEBUG_NEW new(THIS_FILE, __LINE__)
//晕，这是啥米new啊？既不像placement-new也没看见<new>啊

//网上说是new的重载只要满足第一个参数是个SIZE，接下来可以乱（？）搞啦
//MFC把这里得到每个new调用的文件名及所在源文件中的行数记录下来，
//如此当delete时就可以检查所有原申请的内存，
//如果 发现内存指针没有被释放，呵呵，你就惨了（内存泄露了！！），
//这时编译器会告诉你是哪个new（在哪行）申请的内存没被释放。
    
#undef   THIS_FILE     //   取消THIS_FILE的宏定义，使得其暂无定义  
static   char   THIS_FILE[]=__FILE__;     //   定义THIS_FILE指向文件名   
//THIS_FILE 变量，如你所见，作为一个数组存储__FILE__ 
//__FILE__   常量，是编译器能识别的预定义ANSI- C 6宏之一，武功盖世，代表当前文件名（**.cpp）
#endif     //   结束      

BEGIN_MESSAGE_MAP(CFgfgfApp, CWinApp)
//..............  这啥？没东西？呵呵，都说例子在下篇日志咯，这里COMMAND为空do nothing
END_MESSAGE_MAP()

C***App::C***App()  //构造函数，基本设0，除了：
{.........} //m_dwTimeCount = 8（每帧持续8秒）FPS预设90

C***App theApp; //实例了啊实例了啊

BOOL C***App::InitInstance()
{
//公司注册？？汗
	SetRegistryKey(_T("Local AppWizard-Generated Applications"));

//接下来才是真的：构筑窗口作为应用程序的主窗口对象：
	m_pMainWnd = NULL;
	CMainFrame* pFrame = new CMainFrame; //调用CMainFrame类(框架类)了,下篇讲述

//这个Create()函数是CMainFrame类的父亲CFrameWnd的,然后CFrameWnd有个父亲叫CWnd,CWnd有个父亲叫CCmdTarget,CCmdTarget有个父亲叫CObject,(它别名可能叫亚当之子)
	if (!pFrame->Create(NULL,"MFC OpenGL"))
		return FALSE;

//话说回来这个m_pMainWnd是从哪里弹出来的呢?哦~原来是咱们C***App的父亲CWinApp的父亲CWinThread那继承来的啊.(注意,CWinThread父亲就是上面提到的CCmdTarget. 哈都是CObject子孙嘛)
	m_pMainWnd = pFrame; //获得窗口对象
	pFrame->ShowWindow(m_nCmdShow); //显示窗口
	pFrame->UpdateWindow();//更新,重绘屏幕

	return TRUE;
}

int C***App::Run()
{
	if (!m_pMainWnd)
		AfxPostQuitMessage(0);

	MSG msg;
//STATIC_DOWNCAST .....强制类型转换的宏?请看MSDN
//m_pMainWnd 被直接转换为指向CMainFrame类(这编译器转型要求此类必须继承于CObject  - -)的指针了
CMainFrame* pFrame = STATIC_DOWNCAST ( CMainFrame, m_pMainWnd );

//QueryPerformanceFrequency:高精计频器获取一个指向定时器每秒的频率数(m_lPerfCounter ,单位n/s)的指针,并把系统值(CPU时钟频率,每秒嘀哒声的个数)交给它.返回值表明是否支持高精计时
//LARGE_INTEGER,结构体类型,模拟64位有符号的二进制整数 (或者用__int64)
	if ( QueryPerformanceFrequency ( ( LARGE_INTEGER *) &m_lPerfCounter ) ) { 
		
		m_bPerFlag = TRUE; //选择系统时钟

//原默认值为8的m_dwTimeCount 现在就是实时的(n/s)/(f/s)=n/f每帧的频数
		m_dwTimeCount = unsigned long(m_lPerfCounter / m_lFramesPerSecond);

//同样,高精计数器QueryPerformanceCounter 获取用于指向当前"CPU运行到现在的嘀哒数(n)"的指针,并把值交给它(m_lNextTime)来指向
		QueryPerformanceCounter ( ( LARGE_INTEGER * ) &m_lNextTime ); 
		m_dTimeScale = 1.0 / m_lPerfCounter;  //  s/n
	} else  { 

// 如果系统不支持高精计数器,没办法了,用回粗糙的timeGetTime多媒体计时器
		m_lNextTime = timeGetTime ();  

//当然这时高精计频器也没什么作用了,干脆让乘数0.001(相当于m_lPerfCounter取1000)
		m_dTimeScale = 0.001;
	} 

//保存为当前帧的时间(这里其实用计数表示时间),相当于初始化了,接下来它们俩将交替出现
	m_lLastTime = m_lNextTime; 



//******开始了!无限循环,除非出错或退出程序
	while ( TRUE ) {  
//这里我理解为,当有消息发过来,(譬如你最小化啦遮蔽了窗口啦中断(INT)等等,
//就先暂停计时器运算,停继续渲染,先处理所有消息,这个延伸起来很复杂,先放放.
//注意,没有消息来时,PeekMessage会返回一个空值到应用程序，GetMessage会在此时让应用程序休眠。
		if ( ::PeekMessage ( &msg, NULL, 0, 0, PM_NOREMOVE ) ) { 
			do        //如果消息渠里还有消息
			{
				if ( !PumpMessage () )
					return ExitInstance ();
			} 
			while ( ::PeekMessage ( &msg, NULL, 0, 0, PM_NOREMOVE ) );
		} else {   //没消息要处理了,就继续:

//这个摆明了,如果用QueryPerformanceCounter 不行,就用timeGetTime
			if ( m_bPerFlag ) {
	QueryPerformanceCounter ( ( LARGE_INTEGER * ) &m_lCurTime );	
			} 
			else {
	m_lCurTime=timeGetTime (); 
			}

//如果当前计数(代表着时间)到达先前设定的m_lNextTime,譬如从帧1来到帧2 :
			if ( m_lCurTime > m_lNextTime ) { 

// 计算当前时间(刚到达帧2的时间)与刚才帧1开始时间之差,由计数转换为时间表示
	m_dTimeElapsed = ( m_lCurTime - m_lLastTime )  *  m_dTimeScale;
				
// 现在当前帧(帧2)就成了名义上的"上一帧"了,接下来会变成帧2到帧3
				m_lLastTime = m_lCurTime;
				
//这个m_bAppIsActive在CMainframe类里会经常见到,只有它是TRUE时才渲染
//也就是初始化呀屏幕像素设置呀搞好后才开始渲染
				if ( !pFrame->m_bAppIsActive )
					WaitMessage();
				else
					pFrame->RenderGLScene ();

//计算下一帧触发时的计数,即把这个当前计数与刚才高精出来的"每帧的频数(计数)"相加
				m_lNextTime = m_lCurTime + m_dwTimeCount; 

			} // 对应if(m_lCurTime > m_lNextTime)那里

		} // 对应"没消息来了"的那个else

	} // end while
	return msg.wParam;//将返回代码依次返回调用层（退出）

}