Windows有个创建定时任务的命令：SCHTASKS
其具体命令格式如下：
SCHTASKS /parameter [arguments]

描述:
    允许管理员创建、删除、查询、更改、运行和中止本地或远程系统上的计划任
    务。

参数列表:
    /Create         创建新计划任务。

    /Delete         删除计划任务。

    /Query          显示所有计划任务。

    /Change         更改计划任务属性。

    /Run            按需运行计划任务。

    /End            中止当前正在运行的计划任务。

    /ShowSid        显示与计划的任务名称相应的安全标识符。

    /?              显示此帮助消息。

Examples:
    SCHTASKS
    SCHTASKS /?
    SCHTASKS /Run /?
    SCHTASKS /End /?
    SCHTASKS /Create /?
    SCHTASKS /Delete /?
    SCHTASKS /Query  /?
    SCHTASKS /Change /?
我这里以定时运行task.bat批处理文件为例，task.bat内容如下：
notepad
这里为了演示方便，task.bat文件中就notepad一句语句，目的是让其定时运行记事本程序。
接下来创建定时任务的批处理文件createtask.bat，其内容如下：
set base_dir=%~dp0
%base_dir:~0,2%
SCHTASKS /Create /TN mytask /SC ONCE /ST 01:15 /TR  %base_dir%task.bat  
这里需要注意一下，在默认情况下，运行批处理文件的当前路径为C:/Windows/System32，也就是cmd.exe的路径，不是我真正运行批处理的当前路径，为了让其正确指向我的task.bat文件，这里需要获取真正运行的批处理的当前路径，代码中前两行就是获取当前路径的方法，当前路径保存在base_dir中。至于SCHTASKS语法，请自行到cmd下查看帮助说明。

      在我们的日常工作中，我们有时希望程序在指定的时间执行，以为成特定的任务。如对数据库的自动备份、磁盘文件的自动清理等。WINDOWS计划任务就是实现这个功能的一个好工具。
      WINDOWS计划任务分为两种，一种是本地的计划任务(Task Schedule),该类任务我们可以在WINDOWS"控制面板"下的"计划任务"中利用"计划任务向导"进行创建。另一种就是网络的计划任务(Net Schedule)，该类任务与在WINDOWS命令行下的"at"命令等价。通过我查阅资料了解到，两类计划任务可谓各有优缺点。本地计划任务在功能上更加强大，相比起网络计划任务，它提供了更多的接口让用户进行设置。不过创建该类计划任务时必须输入系统中存在的用户名和密码才行，如果不输入或者输入了错误的用户名和密码，计划任务虽然能够创建成功，但是却不能正确的执行。相比本地计划任务，网络计划任务则没有上述限制，只要你当前的用户属于管理员组，就可以成功的创建网络计划任务，并且该任务会在所设定的时间正确的执行。当然，无论对于哪种类的计划任务，在你创建计划任务的时候必须打开"TaskScheduler"服务才行，否则无论创建何种类的计划任务都是无法成功的。
     既然了解了计划任务的基本概念，那下面就让我们来看看微软为我们提供了哪些接口来实现对计划任务进行编程。
     1. 直接使用调用WINDOWS中的"at"命令或者是"schtasks"命令，该方法应该是最简单的。
     2. WMI(本地计划任务)，该方法也还算比较简单。
     3. COM对象ITaskScheduler及其相关对象(本地计划任务)。
     4. COM对象ITaskService及其相关对象(本地任务计划) PS:该对象只在WINDOWS VISTA 和 WINDOWS 7下有效。
     5. 使用网络计划任务API(网络计划任务)
     在这些解决方案中，我选择了最后一种解决方案，因为这是唯一的一种不需要输入用户名和密码的计划任务。虽然该类计划任务在功能上比较弱，如其只能直接支持按周和月的方式定义计划任务，但我们仍能通过其它变通的方法实现需要的功能。
     下面让我们来看看利用API的方式创建计划任务会用到哪些函数和数据结构。
 
      NET_API_STATUS NetScheduleJobAdd(LPCWSTR ServerName, LPBYTE Buffer, LPDWORD jobID)
      函数描述：该函数创建将在系统未来时间中执行的计划任务。该函数需要目标计算机开启Task Scheduler服务。
      安全要求：只有管理员组的用户才能在在远程计算机上执行该函数。
      参数描述：Servername
                     [in]   指向远程主机名称的UNICODE字符串，该字符串必须以"//"(不包含引号)开头，如果该参数为NULL，则执行该函数的计算机为当前正在运行该程序的计算机。
      参数描述：Buffer
                     [in]   指向AT_INFO结构体的指针，该指针用来描述任务的信息。
      参数描述：JobId
                     [out] 新创建作业的ID号，该ID号仅仅在函数执行成功时有效 。
      返回值   ：如果函数执行成功，则返回的值为NERR_Success。
                  ：如果函数执行失败，则返回相应的系统错误执行代码。
 
 
 
 
      NET_API_STATUS NetScheduleJobGetInfo(LPCWSTR ServerName, DWORD JobID, LPBYTE *PointerToBuffer)
      函数描述：获取指定计算机上指定任务的信息，该函数需要目标计算机开启Task Scheduler服务。
      安全要求：只有管理员组的用户才能在在远程计算机上执行该函数。
      参数描述：ServerName
	             [in]    同NetScheduleJobAdd。
      参数描述：JobID
		     [in]    想要获取信息任务的ID号。
      参数描述：PointerToBuffer
		     [out]  指向获取任务信息的AT_INFO结构体指针，请注意该缓冲区由系统分配，在你不需要该信息后，必须使用NetApiBufferFree函数释放。
      返回值   ：如果函数执行成功，则返回的值为NERR_Success。
                  ：如果函数执行失败，则返回相应的系统错误执行代码。
 
 
 
 
      下面让我们来看看与该函数相关的AT_INFO结构体，这是使用该函数的重点
       AT_INFO
       结构描述：该结构体包含作业的信息。当使用NetShceduleJobAdd函数创建一个新的任务时，该函数使用此结构体定义该任务的特性。当使用NetScheduleJobGetInfo函数获取任务信息时，使用该结构体接受信息。
       成员描述：
		      DWORD_PTR JobTime
				定义任务将在执行任务的那一天中的什么时刻执行。该时刻为执行该任务的计算机的本地时间。该时刻以午夜(00:00)为起点开始计算。该成员的单位为毫秒。如将该值设置为1000 * 60 * 60 * 17，则任务将在17:00执行。请注意任务只能精确到分钟执行。
		      DWORD DaysOfMonth
				定义代表月中天数的32位值，如在指定的位上设置为1，该任务会在月中指定的一天上执行。第一位对应月的第一天。按照以上解释，本来我认为可以在多位上置1，以使任务可以在指定的日期上执行。但是实际情况却不行，任务只会在最低位上置1的时间执行，如你将2,3位置位，则任务只会在该月的第二天执行，该原因我一直没有找到，希望哪位牛人在看到本文后能告诉我这是为什么。DaysOfWeek则没有上述的问题。
 		      UCHAR  DaysOfWeek
				定义代表周中天数的8位值，如在指定位上设置为1，该任务会在周中指定的一天上执行，第一位对应周中的第一天。
                      UCHAR Flags
				该变量包含一系列的标志位以用来描述任务的属性。
				当您调用NetScheduleJobAdd函数时，您可以为该变量设置下列几个标志位。
				JOB_RUN_PERIODICALLY
					如果该标志被置位，任务会周期性的执行。反之该任务只会在指定的时间执行一次。当在该任务所设置的所有时间执行完一次后，该任务会自动删除。
				JOB_ADD_CURRENT_DATE
					如果该标志被置位，则将当天加入到任务执行日期中。
				JOB_NONINTERACTIVE
					如果该标志被置位，该任务会在后台执行，反之则会在前台执行。如果任务执行的程序为GUI程序，如果将该标志位设置为1时，则程序的GUI界面不会出现。
				当您调用NetScheduleJobGetInfo函数时，您可以为改变设置以下几个标志位。
				JOB_RUN_PERIODICALLY
					同上
				JOB_EXEC_ERROR
					获取任务在最新一次执行时是否成功。
				JOB_RUNS_TODAY
					任务是否在今天执行过。
				JOB_NONINTERACTIVE
					同上。
			LPWSTR Command
				指向可执行文件的路径的UNICODE字符串。
 
 
 
 
	下面让我们来看一个具体的例子，如何给系统添加一项任务。程序用VB语言实现。
	首先是新建一个模块，命名为mdlTaskScheduler,然后添加下列代码在其中
	Declare Function NetScheduleJobAdd Lib "netapi32.dll" (ByVal servername As String, Buffer As Any, Jobid As Long) As Long
Private Declare Function GetComputerName Lib "kernel32" Alias "GetComputerNameA" (ByVal lpBuffer As String, nSize As Long) As Long
Type AT_INFO
    JobTime     As Long
    DaysOfMonth As Long
    DaysOfWeek  As Byte
    Flags       As Byte
    dummy       As Integer
    Command     As String
End Type
Public Const JOB_RUN_PERIODICALLY = &H1
Public Const JOB_NONINTERACTIVE = &H10
Public Const NERR_Success = 0
Public Function MachineName() As String
    Dim sBuffer As String * 255
    If GetComputerName(sBuffer, 255&) <> 0 Then
        MachineName = Left$(sBuffer, InStr(sBuffer, vbNullChar) - 1)
    End If
End Function 
	
	然后在主界面中加入以下代码
	Private Sub AddTaskSchedule(Byval strTime As String, Byval iTaskDateType As Long, Byref iTaskDates() As Long, Byval bPeriod As Boolean, Byval bInteractive As Boolean, Byval strCommand As String)
    Dim atiInfo As AT_INFO
    If SetATINFO(atiInfo, strTime, iTaskDateType, iTaskDates, bPeriod, bInteractive, strCommand) = False   Then
        Exit Sub
    End If
    
    Dim lResult As Long
    Dim lJobID As Long
    Dim i As Integer
    Dim strComputerName As String
    strComputerName = StrConv("//" & MachineName, vbUnicode)
    lResult = NetScheduleJobAdd(strComputerName, atiInfo, lJobID)
    
    If lResult = NERR_Success Then
        MsgBox "任务 " & lJobID & " 添加成功"
    End If
End Sub
Private Function SetATINFO(ByRef aiInfo As AT_INFO, Byval strTime As String, Byval iTaskDateType As Long, Byref iTaskDates() As Long, Byval bPeriod As Boolean, Byval bInteractive As Boolean, Byval strCommand As String) As Boolean
    If strCommand  = "" Then
        MsgBox "请输入任务路径"
        SetATINFO = False
        Exit Function
    End If
    Dim i As Integer
    With aiInfo
        .JobTime = (Hour(strTime) * 3600 + Minute(strTime) * 60) * 1000
    
        If iTaskDateType = 1 Then ' 每天执行
              For i = 0 To Ubound(iTaskDates) - 1
                .DaysOfWeek = .DaysOfWeek + 2 ^ i
            Next
            .DaysOfMonth = 0
        ElseIf opnType(1).Value Then ' 按周执行
            For i = 1 To Ubound(iTaskDates)
                .DaysOfWeek = .DaysOfWeek + 2 ^ （i - 1） * CInt(chkWeekType(i).Value)
            Next
            .DaysOfMonth = 0
            
            If .DaysOfWeek = 0 Then
                MsgBox "请选择星期"
                SetATINFO = False
                Exit Function
            End If
        Else ' 按月执行
            .DaysOfWeek = 0
            For i = 1 To Ubound(iTaskDates)
                .DaysOfMonth = .DaysOfMonth + 2 ^ (i - 1) * CInt(chkMonthType(i).Value)
            Next
            
            If .DaysOfMonth = 0 Then
                MsgBox "请选择日期"
                SetATINFO = False
                Exit Function
            End If
        End If
        
       If bPeriod Then
            .Flags = .Flags Or JOB_RUN_PERIODICALLY
       End If
       If bInteractive = False Then
            .Flags = .Flags Or JOB_NONINTERACTIVE
       End If
       
       .Command = StrConv(strCommand, vbUnicode)
    End With
    
    SetATINFO = True
End Function 
 
	
	知道了如何添加任务后，让我们再来看看如何删除任务，删除任务需要调用下面的函数。
	NET_API_STATUS NetScheduleJobDel(LPCWSTR ServerName, DWORD MinJobID,  DWORD MaxJobID)
 	函数描述：删除运行在计算机上指定范围内的所有任务。该函数需要目标计算机开启Task Scheduler服务。
	安全要求：只有管理员组的用户才能在在远程计算机上执行该函数。
	参数描述：ServerName
		       [in]   同上。
	参数描述：MinJobID
		       [in]   定义要被删除的最小任务ID号。
	参数描述：MaxJobID
		       [in]   定义要被删除的最大任务ID号。
	返回值   ：如果函数执行成功，则返回的值为NERR_Success。
                    ：如果函数执行失败，则返回相应的系统错误执行代码。
	备注      ：如果您想删除计算机上的所有任务，请将MinJobID的值设置为-1，将MaxJobID的值设置为0。如果您想删除指定的一项任务，请将MinJobID和MaxJobID设为相同的值。
 
	下面让我们来看看删除任务的具体例子。
	首先在模块mdlTaskScheduler中加入以下代码。
	Declare Function NetScheduleJobDel Lib "netapi32.dll" (ByVal servername As String, ByVal MinJobId As Long, ByVal MaxJobId As Long) As Long 
 
	然后在主界面中加入以下代码。
	Private Sub DeleteTaskSchedule(Byval lJobMinID As Long, lJobMaxID As Long)
   Dim strComputerName As String
   strComputerName = StrConv("//" & MachineName, vbUnicode)
   Dim lResult As Long
   lResult = NetScheduleJobDel(strComputerName, lJobMinID, lJobMaxID)
End Sub
				
 
 
	最后在让我们来看看如何获取已经存在任务的各种信息，虽然获取信息可以用上面介绍的NetScheduleJobGetInfo函数获取，但是该函数一次只能获取一条任务信息，所以我在这里使用的是NetScheduleJobEnum来获取任务信息。下面让我们来研究一下该函数。    
	NET_API_STATUS NetScheduleJobEnum(LPCWSTR ServerName,LPBYTE *PointerToBuffer, LPBYTE *PointerToBuffer,
DWORD PreferredMaximumLength, LPDWORD EntriesRead, LPDWORD TotalEntries, LPDWORD ResumeHandle)
	函数描述：获取指定计算机上的计划任务列表，该函数需要目标计算机开启Task Scheduler服务。
	安全要求：只有管理员组的用户才能在在远程计算机上执行该函数。
	参数描述：ServerName
		       [in]   同上。
	参数描述：PointerToBuffer
		       [out] 指向获取任务信息缓冲区的指针。获取的信息以AT_ENUM结构数组的形势存放在该缓冲区中。该缓冲区中的内存由系统分配	
，所以别忘了在不需要的时候使用NetApiBufferFree函数释放该缓冲区。请注意即使函数调用失败，但当返回的结果为ERROR_MORE_DATA时，也必须调用该函数清理缓冲区。
	参数描述：PreferredMaximumLength
		       [in]      定义系统最大分配接收任务信息缓冲区的大小，单位为字节。一般的情况下请定义该值为MAX_PREFERRED_LENGTH，以保证系统会分配足够大的缓冲区。如果该值设置的太小，导致该缓冲区不能获取所有的任务信息，函数会返回ERROR_MORE_DATA。
	参数描述：EnteriesRead
		       [out]     本次函数调用获取的任务信息实际数量
	参数描述：TotalEntries
		       [out]     从当前位置开始将会获得的任务信息数量。
	参数描述：ResumeHandle
		       [in/out] 从列表中的什么位置开始获取任务信息。在第一次调用函数的时候请将该值设置为0,。如果将该值设置为NULL，则不存储该值。
	返回值   ：如果函数执行成功，则返回的值为NERR_Success。
                    ：如果函数执行失败，则返回相应的系统错误执行代码。
 
	下面让我们来看一下AT_ENUM结构体，其实AT_ENUM结构体和AT_INFO结构体在获取任务信息时的各个变量以及变量中的标志位是相同的。
	结构描述：获取任务信息
        成员描述：
			DWORD JobId
				获取任务的ID号。
	     	 	DWORD_PTR JobTime
				同AT_INFO。
	      		DWORD DaysOfMonth
				同AT_INFO。
 		      		UCHAR  DaysOfWeek
				同AT_INFO。
                      	UCHAR Flags	
				该变量包含一系列的标志位以用来描述任务的属性。
				JOB_RUN_PERIODICALLY
					同AT_INFO
				JOB_EXEC_ERROR
					同AT_INFO
				JOB_RUNS_TODAY
					同AT_INFO
				JOB_NONINTERACTIVE
					同AT_INFO
 
	下面就让我们来看一个具体的获取任务信息的例子。首先在mdlTaskScheduler中加入以下代码。
	Declare Function NetScheduleJobEnum Lib "netapi32.Dll " (ByVal servername As String, PointerToBuffer As Any, ByVal PreferredMaximumLength As Long, entriesread As Long, totalentries As Long, resumehandle As Long) As Long
 
Declare Function NetApiBufferFree Lib "netapi32.Dll " (ByVal Buffer As Long) As Long
Declare Sub RtlMoveMemory Lib "Kernel32.Dll " (Destination As Any, Source As Any, ByVal Length As Long) 
	
 
	然后在主界面中加入以下代码。
	Private Sub GetTaskSchdule()
    Dim strComputerName As String
    strComputerName = StrConv("//" & MachineName, vbUnicode)
    
    Dim lResult As Long
    Do
        Dim lBuffer As Long
        Dim lRead   As Long
        Dim lTotal  As Long
        Dim lHandle As Long
        
        lResult = NetScheduleJobEnum(strComputerName, lBuffer, MAX_PREFERRED_LENGTH, _
                        lRead, lTotal, lHandle)
        If (lResult = NERR_Success) Or (lResult = ERROR_MORE_DATA) Then
            Dim i As Long
            Dim aeInfo As AT_ENUM
            For i = 0 To lTotal - 1
                RtlMoveMemory aeInfo, ByVal lBuffer + i * Len(aeInfo), Len(aeInfo)
                ' 处理获取的任务信息
            Next
        End If
        
        If lBuffer <> 0 Then
            NetApiBufferFree lBuffer
        End If
    Loop While lResult = ERROR_MORE_DATA
End Sub 
 
	关于使用API创建网络计划任务的内容就是这些了，这是我第一次写文章，文章中难免有一些疏漏之处。如果有什么不明白的话，
请在我的博客后面留言，如果需要该程序的完整源代码，请将邮件地址留下。
 
 

Windows7的超级任务栏比起常规的windows任务栏主要做了下列改进
 
1、任务栏中的任务图标化，连开始菜单的按钮都显得跟任务栏中的图标差不多样式； 
2、任务栏放弃了实时运行的概念，任务栏中开始变得像桌面，你可以把常用程序的图标放到任务栏上，当你需要使用这个程序的时候不需要回到桌面去点击快捷方式，直接在任务栏上点击就可以，当前正在运行的程序会比当前没有运行的程序在任务栏中多一个外框区分； 
3、可以用WIN键+对应任务栏中图标的顺序数字来打开或者激活该任务； 
4、默认同类任务进行合并，有合并的程序在任务栏中的图标有会根据合并的数量有相应的层数表现； 
5、对于所有其他程序在托盘区的图标都会默认自动隐藏，可以进行图标和通知的自定义，隐藏的图标展开不再是在原任务栏，而是在上方会出现的一个单独框进行显示； 
6、默认取消了快速启动栏； 
7、将“显示桌面”的快捷方式变成了一个不起眼的置于任务栏最右边的小方块； 
8、以媒体库代替了我的电脑，媒体库中列出视频、音乐、文档、图片四类； 
 
 
这些改动虽然在技术上面不是什么新技术，但是能预见对于我们日常使用电脑会带来巨大的影响，它会改变我们的使用习惯，影响我们的电脑观念。对于这些改进所带来的影响总结为以下4点： 
 
1、任务栏桌面化，任务栏集合了部分桌面的功能，桌面的重要性下降，连“返回桌面”的快捷方式都被移到最右边不起眼的角落了，大多数情况下用户操作在任务栏即可完成，不需要返回到桌面，桌面开始转成为了文档临时存放区域，这会带给用户一个新的体验感觉，“操作系统即桌面”转化成了“操作系统即任务栏”； 
2、程序对于任务栏上的进一步支持显得更为重要，一些能够对新任务栏支持的更好的软件会给自己加分，比如能够像WINDOWS7中的WM那样支持在任务栏预览时操作这样的人性化设计更能获得用户的青睐； 
3、托盘区变成真正的托盘区，用户没有主动自定义，程序没办法保持在托盘区露脸，甚至连通知都没办法。对于一些程序这是一件相当糟糕的事情，比如QQ，如果没自定义，声音提示没被注意的时候，新信息来了你是完全无法察觉的，当然这对某些刻意想隐藏自己踪迹的程序来说是个好消息； 
4、用户减少了对桌面的依赖后，对任务栏的依赖程度加深。因为任务栏空间终归有限，他们会尝试将自己最常用的软件放在上面，这些软件的使用频率得到更高的提升。同时由于给用户带来“操作系统即任务栏”的感觉后，用户会花更少的时间进行系统的改进、软件的更替等操作，会更满足于任务栏中常用软件，这让老软件的用户忠诚度更高，新软件获取用户更加困难。软件之间的战争从“占领桌面”、占领“托盘区”转移到“占领任务栏”。 
 
 
 大家一定迫不及待的想针对Windows 7超级任务栏开发一个自己的应用吧，我们来亲自实验2个超级任务栏程序！
（1）基于Visual C++2010开发支持Windows 7超级任务栏缩略图的应用程序
 1.为使在MFC应用程序任务栏缩略图，同时使用MFC应用程序向导，所有用户需要做的是选择“多重文件”的选项“选项卡式文档”功能的应用程序类型。当应用程序运行时，MFC将采取一系列每个视图快照并将其发送到任务栏的API显示为缩略图。

 2.MFC应用程序向导 - 应用类型
在Visual Studio 2010，打开TaskbarThumbnails_Solution / TaskbarthumbnailsDemo.sln解决方案（在源文件夹）。
生成并运行应用程序。打开一些。JPEG图像文件使用的应用程序。悬停在该应用程序演示任务栏上的按钮。
 
 
 
 
 
 
 
（2）开发一个完全展示Windows 7超级任务栏的应用程序
1.打开VS2010，基于MFC创建一个应用程序TaskBarDemo的多文档程序，按照默认向导生成即可，
我们会得到下列的视图。新的任务栏功能的使用提供一个覆盖任务栏图标，进度条，跳跃列表和缩略图预览.
 

 
 
2.在这个程序中，可以切换应用程序的任务栏按钮覆盖图标，当用户点击一个图标的按钮。
在MFC中，可以通过使用一个覆盖图标CFrameWnd：：SetTaskbarOverlayIcon（）。要清除覆盖任务栏图标，传递NULL（0）至SetTaskbarOverlayIcon（）。 。
在TaskbarDemo /源文件，源文件OverlayIconTab.cpp和覆盖图标方法，COverlayIconTab：消息处理程序：OnOverlayIconInfo（）。将使用此消息处理程序添加代码必要在作为一个任务栏图标的按钮覆盖相同的图标。
添加到COverlayIconTab以下代码：：OnOverlayIconInfo（）：
CMainFrame* mainFrm = dynamic_cast<CMainFrame*>(AfxGetApp()->GetMainWnd());
if (mainFrm)
    mainFrm->SetTaskbarOverlayIcon(IDI_ICON_INFO,L"Info");
 
3.编译程序并运行，按下按钮   ，就会发现任务栏的  图标加上了   图标的标志
 

 
 
4.继续加入消息处理代码
void COverlayIconTab::OnOverlayIconQuestion()
{
    //查询图标
    CMainFrame* mainFrm = dynamic_cast<CMainFrame*>(AfxGetApp()->GetMainWnd());
    if (mainFrm)
        mainFrm->SetTaskbarOverlayIcon(IDI_ICON_QUESTION, L"Question");    
}
void COverlayIconTab::OnOverlayIconNoVolume()
{
    // 重新绘制图标
    CMainFrame* mainFrm = dynamic_cast<CMainFrame*>(AfxGetApp()->GetMainWnd());
    if (mainFrm)
        mainFrm->SetTaskbarOverlayIcon(IDI_ICON_NO_VOLUME,L"No Volume"); 
}
void COverlayIconTab::OnOverlayIconNone()
{
    // 清除图标
    CMainFrame* mainFrm = dynamic_cast<CMainFrame*>(AfxGetApp()->GetMainWnd());
    if (mainFrm)                                       
        mainFrm->SetTaskbarOverlayIcon((HICON)0, L"");       
}
 
 
 
 5.在任务栏使用进度条，设置的状态和应用程序的任务栏的进度条的值时，用户从一个组合框或更改该值通过使用滑块的进展情况。 MFC提供了许多方法来更新进度栏任务栏，
CFrameWnd::SetProgressBarRange()
CFrameWnd::SetProgressBarPosition()
CFrameWnd::SetProgressBarState()
在TaskbarDemo /源文件中：
打开文件ProgressBarTab.cpp，和
找到滑块控件的消息处理程序，CProgressBarTab：：OnHScroll（）
添加以下代码来更新后的注释栏的进度栏将代码添加到处理滑杆的变化：
UpdateData();
CMainFrame* mainFrm = dynamic_cast<CMainFrame*>(AfxGetApp()->GetMainWnd());
mainFrm->SetProgressBarPosition(m_ProgressSliderValue);
编译并运行，转到进度栏选项卡。移动滑块，并注意在应用程序的任务栏按钮运动。
效果如下图所示，

 
 滑杆和任务栏按钮进展指标
现在，我们要更新进度条的情况时，组合框选项更新，因此我们添加必要的代码CProgressBarTab：：OnCbnSelchangeProgressStatusCombo（）事件处理程序：
 
CMainFrame* mainFrm = dynamic_cast<CMainFrame*>(AfxGetApp()->GetMainWnd());
switch (m_ProgrssStatusCombo.GetCurSel())
{
case 0 :
    mainFrm->SetProgressBarState(TBPF_NORMAL);
    break;
case 1 :
    mainFrm->SetProgressBarState(TBPF_ERROR);
    break;
case 2 :
    mainFrm->SetProgressBarState(TBPF_PAUSED);
    break;
case 3 :
    mainFrm->SetProgressBarState(TBPF_INDETERMINATE);
    break;
case 4 :
    mainFrm->SetProgressBarState(TBPF_NOPROGRESS);
    break;
default:
    mainFrm->SetProgressBarState(TBPF_NORMAL);
}
 生成并运行应用程序，然后：
导航到进度栏选项卡，
选择一个组合的进展程度不同的样式，然后
移动滑块的进展。进度栏状态将被更改为适当的风格，即任务栏的进度条是红色，进度状态设置为错误，任务栏的进度条是绿色的进展情况时，设置为普通（签出其他样式太）：
最后，这最后一步是可选的，但您可能需要重置状态组合的'正常'的进展情况时，从没有进展或中级更新。要解决此问题，在CProgressBarTab::OnHScroll()添加代码:
 if (m_ProgressSliderValue > 0 && m_ProgrssStatusCombo.GetCurSel() >= 3) // 没有进度条过快
{
   
    m_ProgrssStatusCombo.SetCurSel(0); // 一般状态
}
创建并执行，效果如下

 
 

6.添加任务栏跳转列表
在这项任务中，您将添加的功能，支持加入已知种类，自定义类别，目标和任务应用程序的跳转列表。MFC提供了一个新类，CJumpList，允许操纵的种类和任务栏上的应用程序的JumpList项。
在TaskbarDemo /源文件，打开文件JumpListTab.cpp并寻找执行的CJumpListTab：：UpdateRegistration（）。这种方法执行另一个进程注册所需的文件关联。文件关联注册并不需要在另一个进程，但它是在另一个进程置于保持本教程应用简单focused.Note：
需要注册文件关联，因为应用程序必须是已注册的文件为一个该类型的项目类型的处理程序出现在它的跳转表。这不，但是，必须为该文件类型的默认处理程序。
添加必要的代码，更新注册表和注销jpg文件在相应的信息处理：
 
 
 void CJumpListTab::OnRegisterFileType()
{    
    // 注册
    UpdateRegistration(TRUE);
}
void CJumpListTab::OnUnregisterFileType()
{
    // 解除注册
    UpdateRegistration(FALSE);
}
 接下来的步骤将用于添加必要的代码以添加各种跳转列表项。这里的每个描述：

 
 
 
跳表项目描述
追加已知类别的跳转列表，添加此代码CJumpListTab：：OnAddKnownCategory（）事件处理程序：
int curSel = m_knownCategoryCombo.GetCurSel();
if (curSel < 0)
{
    AfxMessageBox(L"必须选择一个以上的已知类别");
return;
}
if (curSel == 0)
{
    if (m_jumpList.AddKnownCategory(KDC_FREQUENT))
        m_JumpList_Display_Items.AddString(L"Known Category: Frequent");
    else
        AfxMessageBox(L"无法新增频繁已知种类");
} 
else if (curSel == 1)
{
    if (m_jumpList.AddKnownCategory(KDC_RECENT))
        m_JumpList_Display_Items.AddString(L"Known Category: Recent");
    else
        AfxMessageBox(L"失败添加已知种类");
}
 
 为跳转列表添加一个信息描述CJumpListTab::OnAddDestination() :
UpdateData(); // 更新界面
if (m_destinationPath.IsEmpty() || m_destinationCategory.IsEmpty())
{
    AfxMessageBox(L"路径与对象必须添加.");
    return;
}
if (!m_jumpList.AddDestination(m_destinationCategory, m_destinationPath))
{
    AfxMessageBox(L"描述添加失败.");
}
else
{
    CString text = L"Destination: " + m_destinationPath;
    m_JumpList_Display_Items.AddString(text);
}
 
要添加的跳转表的新任务，添加CJumpListTab::OnAddTask() 事件处理程序：
 
UpdateData(); // S更新UI
if (m_taskPath.IsEmpty() || m_taskTitle.IsEmpty())
{
    AfxMessageBox(L"路径与描述必须都存在.");
    return;
}
if (!m_jumpList.AddTask(m_taskPath, m_taskArgs, m_taskTitle, m_taskIconPath, m_taskIconIndex))
{
    AfxMessageBox(L"添加失败.");
}
else
{
    CString text = L"Task: " + m_taskTitle ;
    m_JumpList_Display_Items.AddString(text);
}
要添加的跳转表的新任务，添加CJumpListTab::OnClearAll() 事件处理程序：
m_jumpList.ClearAll();
m_JumpList_Display_Items.ResetContent();
展示表的变化，则在CJumpListTab::OnCommit() 添加事件
if (m_jumpList.CommitList())
{
    m_JumpList_Display_Items.ResetContent();
    m_jumpList.InitializeList();
}
else
{
    AfxMessageBox(L"Failed to commit jump list.");
}
 
F5运行，添加若干个jpg文件，windows7的效果如下

 
 
核心代码如下：
 
 #pragma once

class COverlayIconTab : public CDialog
{
	DECLARE_DYNAMIC(COverlayIconTab)

public:
	COverlayIconTab(CWnd* pParent = NULL);  
	virtual ~COverlayIconTab();
	enum { IDD = IDD_DIALOG_OVERLAY_ICON };

protected:
	virtual void DoDataExchange(CDataExchange* pDX);   

    afx_msg void OnOverlayIconInfo();
    afx_msg void OnOverlayIconQuestion();
    afx_msg void OnOverlayIconNoVolume();
    afx_msg void OnOverlayIconNone();

	DECLARE_MESSAGE_MAP()
};

#include "stdafx.h"
#include "TaskbarDemo.h"
#include "MainTabCtrl.h"
#include "JumpListTab.h"
#include "OverlayIconTab.h"
#include "ProgressBarTab.h"



IMPLEMENT_DYNAMIC(CMainTabCtrl, CTabCtrl)

CMainTabCtrl::CMainTabCtrl()
{
    m_Ids[0] = IDD_DIALOG_OVERLAY_ICON;
    m_Ids[1] = IDD_DIALOG_PROGRESS_BAR;
    m_Ids[2] = IDD_DIALOG_JUMP_LIST;

	m_Dialogs[0] = new COverlayIconTab();
	m_Dialogs[1] = new CProgressBarTab();
	m_Dialogs[2] = new CJumpListTab();

	m_nPageCount = 3;
}

CMainTabCtrl::~CMainTabCtrl()
{
}

void CMainTabCtrl::InitDialogs()
{
    for (int i = 0; i < m_nPageCount; i++)
        m_Dialogs[i]->Create(m_Ids[i],GetParent());
}

void CMainTabCtrl::CreateTabs()
{
	int nSel = GetCurSel();
	if(m_Dialogs[nSel]->m_hWnd)
		m_Dialogs[nSel]->ShowWindow(SW_HIDE);

	CRect l_rectClient;
	CRect l_rectWnd;

	GetClientRect(l_rectClient);
	AdjustRect(FALSE,l_rectClient);
	GetWindowRect(l_rectWnd);
	GetParent()->ScreenToClient(l_rectWnd);
	l_rectClient.OffsetRect(l_rectWnd.left,l_rectWnd.top);

	for(int i=0; i < m_nPageCount; i++){
		m_Dialogs[i]->SetWindowPos(&wndTop, l_rectClient.left,l_rectClient.top,l_rectClient.Width(),l_rectClient.Height(),SWP_HIDEWINDOW);
	}
	
    m_Dialogs[nSel]->SetWindowPos(&wndTop,l_rectClient.left,l_rectClient.top,l_rectClient.Width(),l_rectClient.Height(),SWP_SHOWWINDOW);

	m_Dialogs[nSel]->ShowWindow(SW_SHOW);

}

BEGIN_MESSAGE_MAP(CMainTabCtrl, CTabCtrl)
	//{{AFX_MSG_MAP(CMainTabCtrl)
	ON_NOTIFY_REFLECT(TCN_SELCHANGE, OnSelchange)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()





void CMainTabCtrl::OnSelchange(NMHDR* pNMHDR, LRESULT* pResult) 
{

	CreateTabs();
	*pResult = 0;
}

#include "stdafx.h"
#include "TaskbarDemo.h"
#include "ProgressBarTab.h"
#include "Mainfrm.h"




IMPLEMENT_DYNAMIC(CProgressBarTab, CDialog)

    CProgressBarTab::CProgressBarTab(CWnd* pParent /*=NULL*/)
    : CDialog(CProgressBarTab::IDD, pParent)
    , m_ProgressSliderValue(0)
{
}

CProgressBarTab::~CProgressBarTab()
{
}

void CProgressBarTab::DoDataExchange(CDataExchange* pDX)
{
    CDialog::DoDataExchange(pDX);

    DDX_Control(pDX, IDC_PROGRESS_STATUS_COMBO, m_ProgrssStatusCombo);
    DDX_Control(pDX, IDC_PROGRSS_SLIDER, m_ProgressSlider);
    DDX_Slider(pDX, IDC_PROGRSS_SLIDER, m_ProgressSliderValue);
    DDV_MinMaxInt(pDX, m_ProgressSliderValue, 0, 100);
}

BOOL CProgressBarTab::OnInitDialog()
{
    if (!CDialog::OnInitDialog())
        return FALSE;

    m_ProgrssStatusCombo.SetCurSel(0); // Normal is initially selected

    return TRUE;
}

BEGIN_MESSAGE_MAP(CProgressBarTab, CDialog)
    //}}AFX_MSG_MAP
    ON_CBN_SELCHANGE(IDC_PROGRESS_STATUS_COMBO, &CProgressBarTab::OnCbnSelchangeProgressStatusCombo)
    ON_WM_HSCROLL()

END_MESSAGE_MAP()




void CProgressBarTab::OnCbnSelchangeProgressStatusCombo()
{


}

void CProgressBarTab::OnHScroll(UINT /* nSBCode */, UINT /* nPos */, CScrollBar* pScrollBar )
{
    if (pScrollBar == NULL) // pScrollBar will be NULL if it's a normal scroll bar
        return;



}
#include "stdafx.h"
#include "TaskbarDemo.h"
#include "JumpListTab.h"
#include "Mainfrm.h"



IMPLEMENT_DYNAMIC(CJumpListTab, CDialog)

CJumpListTab::CJumpListTab(CWnd* pParent /*=NULL*/)
	: CDialog(CJumpListTab::IDD, pParent)
    , m_maxSlots(0)
    , m_destinationCategory(_T(""))
    , m_destinationPath(_T(""))
    , m_taskTitle(_T(""))
    , m_taskPath(_T(""))
    , m_taskArgs(_T(""))
    , m_taskIconPath(_T(""))
    , m_taskIconIndex(0)
{

}

CJumpListTab::~CJumpListTab()
{
}

void CJumpListTab::DoDataExchange(CDataExchange* pDX)
{
    CDialog::DoDataExchange(pDX);

    DDX_Text(pDX, IDC_MAX_SLOTS, m_maxSlots);
    DDX_Control(pDX, IDC_JUMP_LIST_ITEMS, m_JumpList_Display_Items);
    DDX_Control(pDX, IDC_KNOWN_CATEGORY_COMBO, m_knownCategoryCombo);
    DDX_Text(pDX, IDC_DEST_CATEGORY, m_destinationCategory);
    DDX_Text(pDX, IDC_DEST_PATH, m_destinationPath);
    DDX_Text(pDX, IDC_TASK_TITLE, m_taskTitle);
    DDX_Text(pDX, IDC_TASK_PATH, m_taskPath);
    DDX_Text(pDX, IDC_TASK_ARGS, m_taskArgs);
    DDX_Text(pDX, IDC_TASK_ICON_PATH, m_taskIconPath);
    DDX_Text(pDX, IDC_TASK_ICON_INDEX, m_taskIconIndex);
    DDX_Control(pDX, IDC_DEST_PATH, m_destinationPathEditBox);
    DDX_Control(pDX, IDC_TASK_PATH, m_taskPathEditBox);
    DDX_Control(pDX, IDC_TASK_ICON_PATH, m_taskIconPathEditBox);
}

BOOL CJumpListTab::OnInitDialog()
{
    if (!CDialog::OnInitDialog())
        return FALSE;

    m_jumpList.InitializeList();
    m_maxSlots = m_jumpList.GetMaxSlots();

    UpdateData(false);

    return TRUE;
}

BEGIN_MESSAGE_MAP(CJumpListTab, CDialog)
    ON_BN_CLICKED(IDC_ADD_KNOWN_CATEGORY, &CJumpListTab::OnAddKnownCategory)
    ON_BN_CLICKED(IDC_ADD_DESTINATION, &CJumpListTab::OnAddDestination)
    ON_BN_CLICKED(IDC_ADD_TASK, &CJumpListTab::OnAddTask)
    ON_BN_CLICKED(IDC_CLEAR_ALL, &CJumpListTab::OnClearAll)
    ON_BN_CLICKED(IDC_COMMIT, &CJumpListTab::OnCommit)
    ON_BN_CLICKED(IDC_SELECT_CATEGORY_PATH, &CJumpListTab::OnSelectDestinationPath)
    ON_BN_CLICKED(IDC_SELECT_TASK_PATH, &CJumpListTab::OnSelectTaskPath)
    ON_BN_CLICKED(IDC_SELECT_TASK_ICON_PATH, &CJumpListTab::OnSelectTaskIconPath)
    ON_BN_CLICKED(IDC_REGISTER_FILE_TYPE, &CJumpListTab::OnRegisterFileType)
    ON_BN_CLICKED(IDC_UNREGISTER_FILE_TYPE, &CJumpListTab::OnUnregisterFileType)
END_MESSAGE_MAP()

// CJumpListTab message handlers

void CJumpListTab::OnAddKnownCategory()
{


}

void CJumpListTab::OnAddDestination()
{


}

void CJumpListTab::OnAddTask()
{


}

void CJumpListTab::OnClearAll()
{

}

void CJumpListTab::OnCommit()
{


}

void CJumpListTab::UpdateRegistration(BOOL isRegister)
{
    CString params;
    
    CString applicationPath;
    AfxGetModuleFileName(0, applicationPath);
    
    params.Format(L"%s /"%s/" /"%s/" /"%s/" %s %s", 
        isRegister ? L"TRUE" : L"FALSE",
        L"Microsoft.Samples.TaskbarDemo", // ProgId
        applicationPath, // Path
        L"TaskbarDemo Document", // friendly doc name
        L"TaskbarDemo.AppID.1.0.0.0", // Taskbar AppUserModeID
        L".jpg"); // extensions
 
    CString shortFileNameParam;    
    AfxGetModuleShortFileName(0, shortFileNameParam);

    CString exeFileName = applicationPath;
    exeFileName.Replace(L"TaskbarDemo.exe", L"RegistrationHelper.exe");

    SHELLEXECUTEINFO shex;

    memset( &shex, 0, sizeof( shex) );

    shex.cbSize         = sizeof( SHELLEXECUTEINFO );
    shex.fMask          = 0;
    shex.hwnd           = this->GetSafeHwnd();
    shex.lpVerb         = _T("runas");
    shex.lpFile         = exeFileName;
    shex.lpParameters   = params;
    shex.lpDirectory    = _T(".");
    shex.nShow          = SW_NORMAL;

    ::ShellExecuteEx( &shex );
}

void CJumpListTab::OnRegisterFileType()
{    

}

void CJumpListTab::OnUnregisterFileType()
{

}

void CJumpListTab::OnSelectDestinationPath()
{
    CFileDialog openDlg(TRUE, NULL, NULL, OFN_FILEMUSTEXIST ,L"Jpeg Files|*.jpg;*.jpeg||");

    if (openDlg.DoModal())
    {
        m_destinationPathEditBox.SetWindowText(openDlg.GetPathName());
    }
}

void CJumpListTab::OnSelectTaskPath()
{
    CFileDialog openDlg(TRUE, NULL, NULL, OFN_FILEMUSTEXIST ,L"Executable Files|*.exe;*.cmd||");

    if (openDlg.DoModal())
    {
        m_taskPathEditBox.SetWindowText(openDlg.GetPathName());
    }
}

void CJumpListTab::OnSelectTaskIconPath()
{
    CFileDialog openDlg(TRUE, NULL, NULL, OFN_FILEMUSTEXIST ,L"Icon Files|*.ico;*.dll;*.exe||");

    if (openDlg.DoModal())
    {
        m_taskIconPathEditBox.SetWindowText(openDlg.GetPathName());
    }
}
#include "stdafx.h"
#include "TaskbarDemo.h"

#include "MainFrm.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#endif


IMPLEMENT_DYNCREATE(CMainFrame, CFrameWndEx)

BEGIN_MESSAGE_MAP(CMainFrame, CFrameWndEx)
	ON_WM_CREATE()
	ON_COMMAND(ID_VIEW_CUSTOMIZE, &CMainFrame::OnViewCustomize)
	ON_REGISTERED_MESSAGE(AFX_WM_CREATETOOLBAR, &CMainFrame::OnToolbarCreateNew)
	ON_COMMAND_RANGE(ID_VIEW_APPLOOK_WIN_2000, ID_VIEW_APPLOOK_WINDOWS_7, &CMainFrame::OnApplicationLook)
	ON_UPDATE_COMMAND_UI_RANGE(ID_VIEW_APPLOOK_WIN_2000, ID_VIEW_APPLOOK_WINDOWS_7, &CMainFrame::OnUpdateApplicationLook)
END_MESSAGE_MAP()

static UINT indicators[] =
{
	ID_SEPARATOR,     
	ID_INDICATOR_CAPS,
	ID_INDICATOR_NUM,
	ID_INDICATOR_SCRL,
};


CMainFrame::CMainFrame()
{
	theApp.m_nAppLook = theApp.GetInt(_T("ApplicationLook"), ID_VIEW_APPLOOK_WINDOWS_7);
}

CMainFrame::~CMainFrame()
{
}

int CMainFrame::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
	if (CFrameWndEx::OnCreate(lpCreateStruct) == -1)
		return -1;

	BOOL bNameValid;
	OnApplicationLook(theApp.m_nAppLook);

	if (!m_wndMenuBar.Create(this))
	{
		TRACE0("Failed to create menubar/n");
		return -1;      // fail to create
	}

	m_wndMenuBar.SetPaneStyle(m_wndMenuBar.GetPaneStyle() | CBRS_SIZE_DYNAMIC | CBRS_TOOLTIPS | CBRS_FLYBY);

	CMFCPopupMenu::SetForceMenuFocus(FALSE);

	if (!m_wndToolBar.CreateEx(this, TBSTYLE_FLAT, WS_CHILD | WS_VISIBLE | CBRS_TOP | CBRS_GRIPPER | CBRS_TOOLTIPS | CBRS_FLYBY | CBRS_SIZE_DYNAMIC) ||
		!m_wndToolBar.LoadToolBar(theApp.m_bHiColorIcons ? IDR_MAINFRAME_256 : IDR_MAINFRAME))
	{
		TRACE0("Failed to create toolbar/n");
		return -1;      // fail to create
	}

	CString strToolBarName;
	bNameValid = strToolBarName.LoadString(IDS_TOOLBAR_STANDARD);
	ASSERT(bNameValid);
	m_wndToolBar.SetWindowText(strToolBarName);

	CString strCustomize;
	bNameValid = strCustomize.LoadString(IDS_TOOLBAR_CUSTOMIZE);
	ASSERT(bNameValid);
	m_wndToolBar.EnableCustomizeButton(TRUE, ID_VIEW_CUSTOMIZE, strCustomize);

	if (!m_wndStatusBar.Create(this))
	{
		TRACE0("Failed to create status bar/n");
		return -1;      // fail to create
	}
	m_wndStatusBar.SetIndicators(indicators, sizeof(indicators)/sizeof(UINT));


	m_wndMenuBar.EnableDocking(CBRS_ALIGN_ANY);
	m_wndToolBar.EnableDocking(CBRS_ALIGN_ANY);
	EnableDocking(CBRS_ALIGN_ANY);
	DockPane(&m_wndMenuBar);
	DockPane(&m_wndToolBar);



	CDockingManager::SetDockingMode(DT_SMART);

	EnableAutoHidePanes(CBRS_ALIGN_ANY);


	EnablePaneMenu(TRUE, ID_VIEW_CUSTOMIZE, strCustomize, ID_VIEW_TOOLBAR);


	CMFCToolBar::EnableQuickCustomization();

	return 0;
}

BOOL CMainFrame::PreCreateWindow(CREATESTRUCT& cs)
{
	if( !CFrameWndEx::PreCreateWindow(cs) )
		return FALSE;


	return TRUE;
}

// CMainFrame diagnostics

#ifdef _DEBUG
void CMainFrame::AssertValid() const
{
	CFrameWndEx::AssertValid();
}

void CMainFrame::Dump(CDumpContext& dc) const
{
	CFrameWndEx::Dump(dc);
}
#endif //_DEBUG



void CMainFrame::OnViewCustomize()
{
	CMFCToolBarsCustomizeDialog* pDlgCust = new CMFCToolBarsCustomizeDialog(this, TRUE /* scan menus */);
	pDlgCust->Create();
}

LRESULT CMainFrame::OnToolbarCreateNew(WPARAM wp,LPARAM lp)
{
	LRESULT lres = CFrameWndEx::OnToolbarCreateNew(wp,lp);
	if (lres == 0)
	{
		return 0;
	}

	CMFCToolBar* pUserToolbar = (CMFCToolBar*)lres;
	ASSERT_VALID(pUserToolbar);

	BOOL bNameValid;
	CString strCustomize;
	bNameValid = strCustomize.LoadString(IDS_TOOLBAR_CUSTOMIZE);
	ASSERT(bNameValid);

	pUserToolbar->EnableCustomizeButton(TRUE, ID_VIEW_CUSTOMIZE, strCustomize);
	return lres;
}

void CMainFrame::OnApplicationLook(UINT id)
{
	CWaitCursor wait;

	theApp.m_nAppLook = id;

	switch (theApp.m_nAppLook)
	{
	case ID_VIEW_APPLOOK_WIN_2000:
		CMFCVisualManager::SetDefaultManager(RUNTIME_CLASS(CMFCVisualManager));
		break;

	case ID_VIEW_APPLOOK_OFF_XP:
		CMFCVisualManager::SetDefaultManager(RUNTIME_CLASS(CMFCVisualManagerOfficeXP));
		break;

	case ID_VIEW_APPLOOK_WIN_XP:
		CMFCVisualManagerWindows::m_b3DTabsXPTheme = TRUE;
		CMFCVisualManager::SetDefaultManager(RUNTIME_CLASS(CMFCVisualManagerWindows));
		break;

	case ID_VIEW_APPLOOK_OFF_2003:
		CMFCVisualManager::SetDefaultManager(RUNTIME_CLASS(CMFCVisualManagerOffice2003));
		CDockingManager::SetDockingMode(DT_SMART);
		break;

	case ID_VIEW_APPLOOK_VS_2005:
		CMFCVisualManager::SetDefaultManager(RUNTIME_CLASS(CMFCVisualManagerVS2005));
		CDockingManager::SetDockingMode(DT_SMART);
		break;

	case ID_VIEW_APPLOOK_VS_2008:
		CMFCVisualManager::SetDefaultManager(RUNTIME_CLASS(CMFCVisualManagerVS2008));
		CDockingManager::SetDockingMode(DT_SMART);
		break;

	case ID_VIEW_APPLOOK_WINDOWS_7:
		CMFCVisualManager::SetDefaultManager(RUNTIME_CLASS(CMFCVisualManagerWindows7));
		CDockingManager::SetDockingMode(DT_SMART);
		break;

	default:
		switch (theApp.m_nAppLook)
		{
		case ID_VIEW_APPLOOK_OFF_2007_BLUE:
			CMFCVisualManagerOffice2007::SetStyle(CMFCVisualManagerOffice2007::Office2007_LunaBlue);
			break;

		case ID_VIEW_APPLOOK_OFF_2007_BLACK:
			CMFCVisualManagerOffice2007::SetStyle(CMFCVisualManagerOffice2007::Office2007_ObsidianBlack);
			break;

		case ID_VIEW_APPLOOK_OFF_2007_SILVER:
			CMFCVisualManagerOffice2007::SetStyle(CMFCVisualManagerOffice2007::Office2007_Silver);
			break;

		case ID_VIEW_APPLOOK_OFF_2007_AQUA:
			CMFCVisualManagerOffice2007::SetStyle(CMFCVisualManagerOffice2007::Office2007_Aqua);
			break;
		}

		CMFCVisualManager::SetDefaultManager(RUNTIME_CLASS(CMFCVisualManagerOffice2007));
		CDockingManager::SetDockingMode(DT_SMART);
	}

	RedrawWindow(NULL, NULL, RDW_ALLCHILDREN | RDW_INVALIDATE | RDW_UPDATENOW | RDW_FRAME | RDW_ERASE);

	theApp.WriteInt(_T("ApplicationLook"), theApp.m_nAppLook);
}

void CMainFrame::OnUpdateApplicationLook(CCmdUI* pCmdUI)
{
	pCmdUI->SetRadio(theApp.m_nAppLook == pCmdUI->m_nID);
}
 
 
需要源码与技术交流的，请在本人CSDN博客留言！
 本文作者专著《Visual C++2010开发权威指南》即将推出，敬请关注，Visual C++2010最近技术，Windows7开发最新技术！
 
 
 
 
 
 
 
 
 
 
 
 
 

背景

该背景叙述与虚拟机的创建过程无关，纯属于个人吐槽，可自行选择略过。


由于一些原因要使用一款零几年的软件，当时连Win7都是新兴事物。然后在我的Win10上无法正常运行，便想使用虚拟机来模拟一个Win7的环境。
本人是Win10系统来用VMware12，然后过了很久没用虚拟机。当我再一次使用VM12的时候，发现我的虚拟机打开进入桌面后就立马死机，无法关闭（一直显示xx虚拟机繁忙），在主机中用任务管理器都无法结束进程，无可奈何只能重启。后来一直出现这种情况，也不知道问题出在了哪里。
后来尝试把VM10和VM12卸载重新安装了许多遍，虚拟机也创建了好多次，花费了我许多时间。无能狂怒砸键盘
最后无意中看到一个网友的评论说Win10系统升级后以前版本的VMware已经无法正常使用了，需要去下载最新版本的VMware。
我尝试了下去下载最新版本的VMware15.5，然后问题就这样简单的解决了。。。。。。

前言

Windows 10无法正常使用VWware12的话直接去官网下载安装最新版本的VMware
写完后发现 威士忌荡出の忧伤这位老哥是真的强
第一次写，望各大佬嘴下留情

1.VMware（虚拟机）安装

目前所接触的虚拟机软件有VirtualBox和VMware两种，但由于亲测使用VirtualBox创建的Win7中鼠标移动过于迟钝（也许是电脑原因），所以选择使用VMware（鼠标移动比较流畅）。
去VMware官网下载一个最新版本的VMware虚拟机。然后会看到比较常见的两种VMware Workstation Player和VMware Workstation Pro，下载后Player后还能继续升级为Pro，所以在这里我简单的把Pro理解为Player的升级版。
这里建议直接下载VMware Workstation Pro，注意取消网站窗口拦截，否则无法弹出下载页面，官网链接已经给了，具体安装过程不再赘述。
至于Player和Pro两者的差别，还望自行百度。这里给个链接：Workstation Player和Workstation Pro介绍，两者的区别

2.Win7镜像（iso镜像文件）下载

网上有许多种版本的iso镜像文件，但有的链接失效或者不是自己想要的版本，感觉不太靠谱，所以这里这里直接推荐去 官网 下载。
点开操作系统，找到你所需要的系统并点击进去，然后右边会出现相关系统的多个版本，根据需要自行选择一个下载 我是随意下载的一个镜像 然后点开详细信息，复制下面的链接到迅雷去下载。



3.Win7虚拟机的创建

打开VMware开始创建新的虚拟机。


然后会出现两个安装选项，一种是软件推荐的典型安装，另一种是自定义安装。由于典型安装的话软件会自动帮你调配虚拟机的一些配置，且后面也几乎是一条龙服务，用户自己配置的东西倒是没有多少。在这里为了能够看到虚拟机更多的配置信息，我选择自定义安装并点击下一步。
开始选择虚拟机硬件兼容性，如果只是自己电脑使用这台虚拟机的话，那就用默认选项即可。VMware随着版本越高对支持的硬件规格越高且限制越少即兼容性更强，这个选项主要是针对改虚拟机在多台电脑上使用的问题。
安装客户机操作系统。在这里如果选择第二项（安装程序光盘映像文件）的话，后面在进入系统时VMware会省去许多步骤并自动执行简易安装。这里为了看到最完整的安装流同样也是详细的步骤所以选择第三个选项（稍后安装操作系统）并点击下一步。ps-这个映像文件就是之前在MSDN下载的ios镜像文件，不要像最初的我一样把ios文件解压了。选择第二选项的时候把文件放上去软件会自动识别系统，下面放一张小图提供展示。
选择客户机操作系统。在这里我展示的是安装Win7 32位，所以选择Microsoft  Windows系统的Windows 7，然后点击下一步。根据自己的需要可以进一步选择是32位还是64位的 Windows7，Windows 7 X64 就是64位的 Win7 系统，同理就只有Windows 7字样的是32位Win7系统，若你安装的是其他版本的系统则直接在版本里面自行选择。

的

6. 命名虚拟机。给这台虚拟机随意命名，默认命名也行，这只是提供用户区分虚拟机。选择这台虚拟机的存放位置，这里推荐放在非C盘中，毕竟一个虚拟机需要的空间较大且C盘也没多大的空间，然后下一步。

7. 处理器配置。处理器的总核数 = 处理器数量 * 每个处理器核数。这里需要根据宿主机的配置来进行选择，如果虚拟机占用处理器过多则宿主机的处理速度就会变慢。我的电脑配置是i5 16G的，这里就选择1x4的处理器然后下一步。

8. 选择虚拟机的内存，通俗来讲就是虚拟机的运行内存。更具宿主机的配置来进行选择，我的是16G的内存，所以这里就直接分配2G内存给虚拟机然后下一步。

9. 选择网络类型。这里直接选择最常见的 使用网络地址转换（NAT）模式，然后下一步。

10. SCSI控制器类型。选择系统默认的LSI Logic SAS 即可。

11. 选择磁盘类型：选择默认的SCSI选项即可。

12. 选择磁盘：选择创建新虚拟磁盘，即默认选项。

13. 设置磁盘容量：选择默认的 60 G即可，根据自己需要适当调整。这里的设置的磁盘并不会立刻占用60G的空间，这个是会随着虚拟机的时候慢慢增加的，最大就是你设置的磁盘大小，这里是60G，后期也可以根据自己的需求更改磁盘大小。为了提高磁盘性能，这里选择将虚拟磁盘存储为单个文件较好。

14. 指定磁盘文件：没有特别命名要求的话直接就默认然后下一步吧。

15. 已经准备好创建虚拟机：这里不要急着点完成，先打开自定义硬件进行设置。

16. 在硬件设置中，打印机一般都用不上，直接把打印机移除掉。

17. 补上之前没有安装的ios镜像文件：先点开新CD/DVD (SATA)选项然后点击使用IOS映像文件，点击游览找到之前下载Win7镜像文件（文件命会因为当初下载的版本不同而不同）然后点击打开。

18. 导入完成后关闭自定义硬件界面，然后点击完成。

19. 安装完成后开始打开虚拟机。

20. 打开虚拟机后骚等一会儿进入Windows安装界面，在确认语言时间输入法没毛病（一般都是默认）后就进入下一步。

21. 然后直接点击现在安装。

22. 然后是接受许可条款，并点击下一步。

23. 接着选择自定义(高级)安装。

24. 接下来开始划分磁盘了，我准备划分出60G中1/3的空间(20G)用来当系统盘，点击“磁盘0 未分配的空间”后会出现刷新、新建等按钮，然后点击新建按钮输入需要划分的大小，1G=1024MB，所以我划出20480MB的空间出来，然后点击应用。

25. 点击 应用 后会弹出提醒框，我们直接点击确认即可。

26. 就这样划出了大小为20GB的分区2，然而实际上他只有19.9GB的原因是系统工具自动占用了100MB的空间来放VMware Tool，所以就只剩下19.9GB了。然后点击划分的分区2点击格式化并点击弹出提醒框中的确认按钮。每划分一个分区就格式化一次，以此类推。

PS：这里我只划分了一个系统盘，还有40G的空间未分配，直接下一步的话后面进入桌面只会显示一个20G的C盘。这里还需要自己再分配几个磁盘空间以供后期使用，若只是划分了一个系统盘而没有划分其他盘的话可以去看：虚拟机Win 7中重新 划分 分区 合并 磁盘



27. 然后选择分区2来安装系统，开始下一步。

28. 然后就是一个比较漫长的安装等待过程。

29. 安装完成后注册用户，根据个人喜好命名，然后下一步。

30. 根据需要设置用户密码，也可以不设置密码 实际只是我太懒不想记 ，看个人意愿，然后点击下一步。

31. 然后是激活产品，这一先取消提醒然后直接下一步。ps-这个激活密钥我没有，所以直接跳过。。。。。。

32. 直接点击 以后询问我，进入下一步。

33. 时间一般没问题，直接进入下一步。

34. 为了避免不必要的麻烦，这里直接选择 公共网络。

35. 骚等一会后就进入桌面了。

36. 进入桌面后鼠标右键打开个性化，然后点击更改桌面图标，选择需要的图标最好点击确认即可。

37. 然后基本上可以使用了。
资料参考：

VMware官网
Workstation Player和Workstation Pro介绍，两者的区别
 MSDN 
史上最详细的虚拟机VMware12安装Windows7教程
VMware虚拟机安装Windows7
虚拟机Win 7中重新 划分 分区 合并 磁盘