精华内容
下载资源
问答
  • scratch少儿编程入门怎么学习?不少家长对孩子scratch编程学习比较重视,对于孩子scratch编程怎样入门没有一些好的正确的学习方法,那么在这里,也给大家做一个分享!1.根据孩子的特点教学编程入门相信很多爸妈都不...

    d556228dddf7cf384a45557e7c73a3fc.png

    scratch少儿编程入门怎么学习?

    不少家长对孩子scratch编程学习比较重视,对于孩子scratch编程怎样入门没有一些好的正确的学习方法,那么在这里,也给大家做一个分享!

    b4bbd10c204f6416cc2d7835c5b05362.png


    1.根据孩子的特点教学编程入门

    相信很多爸妈都不太理解scratch少儿编程,所以在没有很好的教学经验,不知道如何下手,作为一个过来人建议大家可以去找关于scratch少儿编程的书籍阅读视频,看看scratch少儿编程入门学习视频课程,其中有一个方面就是说如何按照孩子的兴趣教学。

    这也是起初我们让孩子学习编程最需要做的一个方面,那么如何高效地进行scratch少儿编程入门学习,事实上在零基础少儿的编程启蒙过程中,首先要解决的问题是--认识问题和一个引导的问题,而不是快速上手的问题,这一点一定要注意,足够的认识和相关的理解会让孩子觉得有趣,觉得scratch少儿编程学习的很有意义,这样才会孩子的后续的学习有更深的引导下过。

    0fda8404a3588f75a18ef6090a823651.png

    2.专业环境影响很重要

    我们周围环境有限,所以不能提供专业化的教学,所以可以孩子找专业的scratch课程学习,现在网上课程学习也挺方便的,有专业的专业老师固定教学,课堂中注重编程能力的培养,而且学习环境专门有为入门的学生定制的原版视频趣味教学方法,提高孩子的学习效果。

    scratch少儿编程入门学习不管是自己教孩子还是找专业的编程课程学习,都是缺一不可的,毕竟是新的知识内容,编程习惯和思维方式选专业的老师辅导效果更好些。

    儿童编程教育的好处培养孩子逻辑思维能力,并不是将孩子培养成程序员,所以更注重孩子学习体验,寓教于乐为主,激发孩子编程学习积极性。0基础孩子学习编程,前期给孩子树立正确的编程观,讲解编程工具使用,让孩子熟悉编程工具功能键及单位换算,明白所有的操作之后在进行实践。这是一个循序渐进的过程,如同孩子第一次接触母语、英语,从简单的字母发音、语法开始练习,所以家长不必担心孩子学不上。

    0ad6a4f985204b766861eca9e9654e76.png

    杭州少儿编程培训机构排行榜怎么选择?

    学习编程是一项投资,建议家长在给孩子选择培训班时一定要慎重,不要只考虑课程价格及收费标准,更应该关注课程质量、师资水平、教学效果,选择一家性价比高的学校,而不是便宜的培训班。

    当然也要考虑到孩子的感受,绝大部分孩子都觉得编程课程十分有趣。因为编程课程气氛轻松,可以玩电脑在上面移动模块,每次完成系统的指令都有一种莫名的成就感,特别是屏幕上的人物或动物正常运行时,就会发出由内而外的喜悦之情。偶尔遇到困难,寻求帮助或独自解决都能够收获满满。所以,边学习边玩耍,孩子是玩得开心的,从而在欢乐中进步。

    0ae7e264cd72e2898575cf66a4865fed.png
    展开全文
  • 那么,初学者怎样快速入门Python编程呢?了解 Python 编程基础首先第一点,要能够看懂了解变量、基础语法、编程规范等,这些事能够上手编写Python 代码的前提。其次第二点,对于数据结构,字符串、列表、字典等需要...

    【摘要】现如今,我们工作中的许多工作都需要通过编写计算机软件来完成。Python是一种跨平台的计算机程序设计语言,通过Python编程,我们能够解决现实生活中的很多困难。那么,初学者怎样快速入门Python编程呢?

    71efa2ffe5da6462a9a2723bd2c4a735.png

    了解 Python 编程基础

    首先第一点,要能够看懂了解变量、基础语法、编程规范等,这些事能够上手编写Python 代码的前提。

    其次第二点,对于数据结构,字符串、列表、字典等需要比较熟练运用。

    刚开始的这部分就做一些简单的练习,构造出一个数据类型,然后再实现基本的用法。比如你自己构造一个列表,实现列表中数据的访问、更新、删除等基本操作,比如len()、max()、min() 函数,以及 append()、count()、extend() 等方法。

    Python函数及流程控制

    有了前面的基础练习之后,学习Python的函数和控制语句,是真正去解决问题的过程,如何将固定的功能模块封装成函数,如何实现判断和循坏,这些不仅是写出代码的必要条件,也是训练编程思维的必经之路。

    流程控制比较好掌握一些,条件语句和循坏语句在不同的场景下练习几遍,知道判断和循环实现的过程就行。

    利用Python做些事情

    在前期的理论知识学透之后,你不妨尝试着利用利用Python做些事情,检验自己的学习成果,这样也能够巩固加深自己学习的理论知识。同时,可以查漏补缺,看看自己哪方面需要保持,哪方面需要继续学习。

    这个时候不妨了解一些第三方库,你可以做更多的事情。对于不同的库,内部的方法、函数你还需要去熟悉,开始的时候先掌握少部分最常用的方法,在遇到实际的问题的时候,再去查对应的更多的用法,这样会更高效。

    首先需要了解Python的高级特性,如迭代器、生成器、装饰器等,了解类和面向对象的理念。深入下去,你可以去探索Python的实现原理,Python的性能优化,跳出Python语言本身,去了解计算机的交互原理,还有很长的路要走,但并不是每一个人都需要这个过程。

    但这些确实是你在这个领域立足生根的重要条件,对于特别想要在IT行业发展的人来说,这个过程是非常有必要的。

    关于初学者怎样快速入门Python编程,环球青藤小编就和大家分享到这里了,学习是永无止境的,学习一项技能更是受益终身,所以,只要肯努力学,什么时候开始都不晚。如果您还想继续了解关于python编程的学习方法及素材等内容,可以点击本站其他文章学习。

    展开全文
  • VS2010 MFC编程入门教程

    2020-10-22 20:04:33
    C++ 编程入门系列给大家讲了 C++ 的编程入门知识,大家对 C++ 语言在语法和设计思想上应该有了一定的了解。在这套 VS2010/MFC编程入门教中,将会给大家讲解怎样使用 VS201进行可视化编程。
  • 标签:MatlabMATLAB是美国MathWorks公司出品的商业...MATLAB编程MATLAB编程本文为StephenJ.Chapman《MATLAB编程(第二版)》英文影印版的中文译本,这本书对初学者很好的入门教材。非扫描,清晰文档内容节选有 MATLA...

    标签:

    Matlab

    MATLAB是美国MathWorks公司出品的商业数学软件,用于算法开发、数据可视化、数据分析以及数值计算的高级技术计算语言和交互式环境,主要包括MATLAB和Simulink两大部分。MATLAB编程

    MATLAB编程

    本文为Stephen J.Chapman《MATLAB 编程(第二版)》英文影印版的中文译本,这本 书对初学者很好的入门教材。非扫描,清晰

    文档内容节选

    有 MATLAB 编程问题的朋友,可以联系我 联系方式: QQ:993878382 Email:matlabmanqqcom 个人博客:httptop99bloghexuncom46036333dhtml 如果我 QQ 不在线,你可将问题发到我的邮箱,或者在我的博客留 言,可以为你提供解决问题的思路,同探讨,共进步 MATLAB 编程 第二版 Stephen J Chapman 著 邢树军 郑碧波译 国外高校电子信息类优秀教材英语影印版 MATLAB 编程 第二版 MATLAB Programming for Engineers Second Edition Stephen J Chapman 著 邢树军 郑碧波 译 前言 郑碧波 本文为 Stephen JChapmanMATLAB 编程第二版英文影印版的中文译本,这本 书对初学者很好的入门教材之前从网上下载到邢树军兄弟译的 pdf 版本,邢的这个版本用 起来有以下几方面不便: 1文件较大 2打开之后总是提示播放......

    更多简介内容

    推荐帖子

    评论

    学习了,谢谢分享。

    2018-08-14 20:02:20

    展开全文
  • VS2010MFC编程入门

    2019-09-23 01:09:43
    一、MFC编程入门教程之目录 第1部分:MFC编程入门教程之目录 1.MFC编程入门之前言 鸡啄米的C++编程入门系列给...鸡啄米在这套VS2010/MFC编程入门教程中将会给大家讲解怎样使用VS2010进行可视化编程,也就是基...

     

    一、MFC编程入门教程之目录

    第1部分:MFC编程入门教程之目录

    1.MFC编程入门之前言

     鸡啄米的C++编程入门系列给大家讲了C++的编程入门知识,大家对C++语言在语法和设计思想上应该有了一定的了解了。但是教程中讲的例子只是一个个简单的例程,并没有可视化窗口。鸡啄米在这套VS2010/MFC编程入门教程中将会给大家讲解怎样使用VS2010进行可视化编程,也就是基于窗口的程序。
           C++编程入门系列主要偏重于理论方面的知识,目的是让大家打好底子,练好内功,在使用VC++编程时不至于丈二和尚摸不着头脑。本套教程也会涉及到VC++的原理性的东西,同样更重视实用性,让大家学完本套教程以后,基本的界面程序都能很容易编写出来。
           VC++简介
           VC++全称是Visual C++,是由微软提供的C++开发工具,它与C++的根本区别就在于,C++是语言,而VC++是用C++语言编写程序的工具平台。VC++不仅是一个编译器更是一个集成开发环境,包括编辑器、调试器和编译器等,一般它包含在Visual Studio中。Visual Studio包含了VB、VC++、C#等编译环境。当然我们在使用VC++ 6.0的时候为了轻便,总是只单独安装VC++ 6.0。但自微软2002年发布Visual Studio.NET以来,微软建立了在.NET框架上的代码托管机制,一个项目可以支持多种语言开发的组件,VC++同样被扩展为支持代码托管机制的开发环境,所以.NET Framework是必须的,也就不再有VC++的独立安装程序,不过可以在安装Visual Studio时只选择VC++进行安装。
    
           VC++版本的选择:VS2010
           因为VC++ 6.0以后的版本不再有独立的安装程序,所以鸡啄米在教程中将不会称VC++ 6.0以后的版本为VC++ 7.0等等,而是用VC++所属的Visual Studio的版本名称代替,比如VS2003。
           近些年VC++主要的版本包括:VC++ 6.0、VS2003、VS2005、VS2008和VS2010。
           VC++ 6.0占用的系统资源比较少,打开工程、编译运行都比较快,所以赢得很多软件开发者的青睐。但因为它先于C++标准推出,所以对C++标准的支持不太好。举个例子:
           for(int i=0; i<5; i++)
           {
                    a[i] = i;
           }
           for语句中声明的变量i,对于VC++ 6.0来说,出了for循环仍能使用。但很显然这与C++标准对于变量生存期的规定不符合。
           随着VC++版本的更新,对C++标准的支持越来越好,对各种技术的支持也越来越完善。但同时新版本所需的资源也越来越多,对处理器和内存的要求越来越高。到VS2010,光安装文件就2G多,安装后的文件占3G多空间,其运行也经常受处理器和内存等性能的限制。但鸡啄米还是推荐大家使用VS2010,毕竟它是最新版本,类库和开发技术都是最完善的,本教程也将使用VS2010为大家做例程的演示。当然如果系统配置确实比较低,可以选择VS2005,VS2005和VS2010相比还是要轻量级一些的。VC++ 6.0已经过时,奉劝大家尽量别用了。
           VC++与MFC
           讲VC++免不了要提MFC,MFC全称Microsoft Foundation Classes,也就是微软基础类库。它是VC++的核心,是C++与Windows API的结合,很彻底的用C++封装了Windows SDK(Software Development Kit,软件开发工具包)中的结构和功能,还提供了一个应用程序框架,此应用程序框架为软件开发者完成了一些例行化的工作,比如各种窗口、工具栏、菜单的生成和管理等,不需要开发者再去解决那些很复杂很乏味的难题,比如每个窗口都要使用Windows API注册、生成与管理。这样就大大减少了软件开发者的工作量,提高了开发效率。
           当然VC++不是只能够创建MFC应用程序,同样也能够进行Windows SDK编程,但是那样的话就舍弃了VC++的核心,放弃了VC++最强大的部分。MFC也不是只能用于VC++中,它同样也可以用在Borland C++等编译器中,当然没有几个人这样做。
           本节旨在让大家对VC++、VS2010和MFC有基本的概念上的认识,后面鸡啄米会带大家进入VS2010/MFC的世界,让大家轻松的开发各种包含窗口、图形等的可视化程序。
    View Code

    2.VS2010与MSDN安装过程图解

       上一讲中鸡啄米对VC++和MFC做了一些简单介绍。在本套教程中鸡啄米将使用VS2010为大家讲解如何使用VC++和MFC进行编程,所以首先要安装VS2010。
           一.下载VS2010
           首先我们需要下载VS2010,大家可以在网上下载VS2010破解正式版,建议选择英文版,养成使用英文工具的习惯。鸡啄米使用VS2010旗舰试用版VS2010UltimTrial.iso为例介绍安装过程,旗舰试用版官方下载地址为:http://www.microsoft.com/download/en/details.aspx?displaylang=en&id=12187。正式版的安装过程与试用版类似。
           二.安装VS2010
           下载后进行安装。安装方法与一般的iso文件一样,可以使用虚拟光驱软件Daemon Tools安装,也可以将其解压后点击setup.exe进行安装。
           鸡啄米为了让大家更直观的看到安装过程,我将在自己机子上再重新安装一次,并截图为大家讲解。
           这里使用Daemon Tools安装VS2010。首先打开Daemon Tools,屏幕右下角会出现托盘图标,在图标上点右键,会弹出菜单,再把鼠标移到菜单项“虚拟设备”上,然后再移到子菜单项“设备 0:[L:] 无媒体”上,最后点击下一级子菜单项“装载映像”,弹出对话框选择VS2010UltimTrial.iso文件。
    
           这样虚拟光驱就会打开此iso文件,弹出自动安装的提示,选择“运行autorun.exe”就可以了,如果没有弹出提示就通过资源管理器进入虚拟光驱,用setup.exe安装。接着会弹出下面的对话框:
    
           当然选择“Install Microsoft Visual Studio 2010”进入下一步,加载安装组件后如下显示:
    
        点“Next”后:
    
             选择“I have read and accept the license terms”后点“Next”弹出对话框:
    
           此处是让我们选择要安装的功能,有两种:Full(完全)和Custom(自定义)。Full选项表示安装所有编程语言和工具,Custom选择表示可以自定义要安装的编程语言和工具。右侧可以更改安装路径,鸡啄米建议不要安装到C盘,因为它占用的空间比较大。鸡啄米安装到了D盘,使用Full完全安装。如果选择Custom安装,点“Next”则出现如下画面:
    
           大家可以根据自己的需要取消某些语言或工具的安装,比如不想安装Visual C#,取消选择它就可以了。如果觉得以后都有可能会用到,那就像鸡啄米一样选择完全安装吧。
           Full或Custom方式和安装路径设置好后,点“Install”进行安装:
     
    
             可能正式版的安装文件在安装过程中会有重启过程。鸡啄米使用的试用版中间并没有重启。安装完成:
    
             如果要继续安装MSDN,先不要卸载虚拟光驱映像。
             三.安装MSDN
             我们使用VS2010进行软件开发同样离不开帮助文档,即MSDN。在本地安装MSDN的方法如下:
             在开始菜单的“所有程序”->“Microsoft Visual Studio 2010”->“Visual Studio Tools”下选择“Manage Help Settings - ENU”:
    
             弹出对话框:
    
             可以将帮助库存在默认路径,也可以修改存放路径。鸡啄米使用默认路径,点“OK”出现:
    
            选择“Install Content From Disk”后弹出对话框选择帮助所在文件,这时需要在加载了VS2010的虚拟光驱中找,选择图中所示路径:
     
    
            点OK后出现如下对话框,可以点“Add”选择要添加的帮助库,鸡啄米全部添加了。
     
    
             点“Update”进行安装,等待其完成就可以了。
             使用MSDN时点击开始菜单的“所有程序”->“Microsoft Visual Studio 2010”->“Microsoft Visual Studio 2010 Documentation”即可。
             到此VS2010和MSDN的安装过程就结束了。以后就可以正式使用VS2010进行软件开发了。至于VS2010的使用方法在鸡啄米的C++编程入门系列中已经介绍过,大家可以看看。
    View Code

    第2部分:MFC应用程序框架

    1.利用MFC向导生成单文档应用程序框架

    上一讲中讲了VS2010和MSDN如何安装,相信大家都已经安装好了。这一讲给大家一个简单的例子,演示如何生成单文档应用程序框架。
          解决方案与工程
          鸡啄米在VS2010的使用介绍中已经讲了解决方案与工程的概念,这里再重提一下。每个应用程序都作为一个工程来处理,它包含了头文件、源文件和资源文件等,这些文件通过工程集中管理。在VS2010中,工程都是在解决方案管理之下的。一个解决方案可以管理多个工程,可以把解决方案理解为多个有关系或者没有关系的工程的集合。VS2010提供了一个Solution Explorer解决方案浏览器视图,可以显示当前解决方案的内容,当新建一个工程时可以选择新建一个解决方案还是加入当前解决方案。
           下图左侧面板中正在显示的视图就是Solution Explorer,视图中有一个解决方案-HelloWorld,此解决方案下有一个同名的工程-HelloWorld。
    
          在应用程序向导生成应用程序后,VS2010会在用户设置的路径下,以解决方案名为名称建立一个目录,里面存放自动生成的文件。
          使用VS2010应用程序向导生成单文档应用程序框架
          鸡啄米这里简略演示下怎样生成单文档应用程序框架,让大家先有个直观的了解,有不理解的地方可以留着以后回来再看。下面按照操作步骤一步步讲解:
          1.点菜单栏File->New->Project,弹出New Project对话框,我们可以选择工程类型。
          如果安装完VS2010以后第一启动时已经设置为VC++,则Installed Templates->Visual C++项会默认展开,而如果没有设置VC++,则可以展开到Installed Templates->Other Languages->Visual C++项。因为我们要生成的是MFC程序,所以在“Visual C++”下选择“MFC”,对话框中间区域会出现三个选项:MFC ActiveX Control、MFC Application和MFC DLL。MFC ActiveX Control用来生成MFC ActiveX控件程序。MFC Application用来生成MFC应用程序。MFC DLL用来生成MFC动态链接库程序。当然我们要选择MFC Application。
          在对话框下部有Name、Location和Solution name三个设置项。意义如下:Name--工程名,Location--解决方案路径,Solution name--解决方案名称。这里Name我们设为“HelloWorld”,Location设置为“桌面”的路径,Solution name默认和Name一样,当然可以修改为其他名字,这里我们不作修改,也使用“HelloWorld”。点“OK”按钮。
    
    
          2.这时会弹出“MFC Application Wizard”对话框,上部写有“Welcome to the MFC Application Wizard”,下面显示了当前工程的默认设置。第一条“Tabbed multiple document interface (MDI)”是说此工程是多文档应用程序。如果这时直接点下面的“Finish”按钮,可生成具有上面列出设置的多文档程序。但我们此例是要建立单文档应用程序,所以点“Next”按钮再继续设置吧。
          3.接下来弹出的对话框上部写有“Application Type”,当然是让选择应用程序类型,我们看到有四种类型:Single document(单文档)、Multiple documents(多文档)、Dialog based(基于对话框)和Multiple top-level documents。我们选择Single document类型,以生成一个单文档应用程序框架。单文档应用程序运行时是一个单窗口界面。
     
    
          此对话框的“Resource language”还提供语言的选择,这里默认选择英语。“Project style”可选择工程风格,我们选择默认的“Visual Studio”风格。“Use of MFC”有两个选项:Use MFC in a shared DLL(动态链接库方式使用MFC)和Use MFC in a static library(静态库方式使用MFC)。选择Use MFC in a shared DLL时MFC的类会以动态链接库的方式访问,所以我们的应用程序本身就会小些,但是发布应用程序时必须同时添加必要的动态链接库,以便在没有安装VS2010的机子上能够正常运行程序。选择Use MFC in a static library时MFC的类会编译到可执行文件中,所以应用程序的可执行文件要比上种方式大,但可以单独发布,不需另加包含MFC类的库。这里我们使用默认的Use MFC in a shared DLL。点“Next”按钮。
          4.此时弹出上部写有“Compound Document Support”的对话框,可以通过它向应用程序加入OLE支持,指定OLE选项的复合文档类型。本例不需要OLE特性,使用默认值“None”。点“Next”按钮。
          5.弹出的新对话框上部写有“Document Template Properties”。“File extension”可以设置程序能处理的文件的扩展名。对话框其他选项还可以更改程序窗口的标题。我们都使用默认设置,点“Next”按钮。
          6.此时弹出的对话框主题是“Database Support”。用于设置数据库选项。此向导可以生成数据库应用程序需要的代码。它有四个选项:
          None:忽略所有的数据库支持;
          Header files only:只包含定义了数据库类的头文件,但不生成对应特定表的数据库类或视图类;
          Database view without file support:创建对应指定表的一个数据库类和一个视图类,不附加标准文件支持;
          Database view with file support:创建对应指定表的一个数据库类和一个视图类,并附加标准文件支持。
          本例选择默认值“None”,不使用数据库特性。点“Next”按钮。
          7.这时弹出的对话框是关于“User Interface Features”,即用户界面特性。我们可以设置有无最大化按钮、最小化按钮、系统菜单和初始状态栏等。还可以选择使用菜单栏和工具栏生成简单的应用程序还是使用ribbon。这里我们都选择默认设置。点“Next”进入下一步。
          8.此时弹出“高级特性”对话框。可以设置的高级特性包括有无打印和打印预览等。在“Number of files on recent file list”项可以设置在程序界面的文件菜单下面最近打开文件的个数。我们仍使用默认值。点“Next”按钮。
          9.弹出“生成类”对话框。在对话框上部的“生成类”列表框内,列出了将要生成的4 个类:一个视图类(CHelloWorldView)、一个应用类(CHelloWorldApp)、一个文档类(CHelloWorldDoc)和一个主框架窗口类(CMainFrame)。在对话框下面的几个编辑框中,可以修改默认的类名、类的头文件名和源文件名。对于视图类,还可以修改其基类名称,默认的基类是CView,还有其他几个基类可以选择。这里我们还是使用默认设置。点“Finish”按钮。
          应用程序向导最后为我们生成了应用程序框架,并在Solution Explorer中自动打开了解决方案(见上面第一张图)。
          编译运行生成的程序
          点菜单中的Build->Build HelloWorld编译程序,然后点Debug->Start Without Debugging(快捷键Ctrl+F5)运行程序,也可以直接点Debug->Start Without Debugging,这时会弹出对话框提示是否编译,选择“Yes”,VS2010将自动编译链接运行HelloWorld程序。结果页面如下所示:
    
           终于看见界面了。鸡啄米在以后的教程中会继续讲解各种界面和控件的使用方法。欢迎到鸡啄米博客交流,您的关注是我前进的动力。
    View Code

    2.VS2010应用程序工程中文件的组成结构

    鸡啄米在上一讲中为大家演示了如何利用应用程序向导创建单文档应用程序框架。这一节将以上一讲中生成应用程序HelloWorld的文件结构为例,讲解VS2010应用程序工程中文件的组成结构。
           用应用程序向导生成框架程序后,我们可以在之前设置的Location下看到以解决方案名命名的文件夹,此文件夹中包含了几个文件和一个以工程名命名的子文件夹,这个子文件夹中又包含了若干个文件和一个res文件夹,创建工程时的选项不同,工程文件夹下的文件可能也会有所不同。
           如果已经以Debug方式编译链接过程序,则会在解决方案文件夹下和工程子文件夹下各有一个名为“Debug”的文件夹,而如果是Release方式编译则会有名为“Release”的文件夹。这两种编译方式将产生两种不同版本的可执行程序:Debug版本和Release版本。Debug版本的可执行文件中包含了用于调试的信息和代码,而Release版本则没有调试信息,不能进行调试,但可执行文件比较小。
           鸡啄米将所有文件分为6个部分:解决方案相关文件、工程相关文件、应用程序头文件和源文件、资源文件、预编译头文件和编译链接生成文件。
           1.解决方案相关文件
           解决方案相关文件包括解决方案文件夹下的.sdf文件、.sln文件、.suo文件和ipch文件夹。
           .sdf文件和ipch目录一般占用空间比较大,几十兆甚至上百兆,与智能提示、错误提示、代码恢复和团队本地仓库等相关。如果你觉得不需要则可以设置不生成它们,方法是点击菜单栏Tools->Options,弹出Options对话框,选择左侧面板中Text Editor->C/C++->Advanced,右侧列表中第一项Disable Database由False改为True就可以了,最后关闭VS2010再删除.sdf文件和ipch目录以后就不会再产生了。但关闭此选项以后也会有很多不便,例如写程序时的智能提示没有了。
           .sln文件和.suo文件为MFC自动生成的解决方案文件,它包含当前解决方案中的工程信息,存储解决方案的设置。
           2.工程相关文件
           工程相关文件包括工程文件夹下的.vcxproj文件和.vcxproj.filters文件。
           .vcxproj文件是MFC生成的工程文件,它包含当前工程的设置和工程所包含的文件等信息。.vcxproj.filters文件存放工程的虚拟目录信息,也就是在解决方案浏览器中的目录结构信息。
    
           3.应用程序头文件和源文件
           应用程序向导会根据应用程序的类型(单文档、多文档或基于对话框的程序)自动生成一些头文件和源文件,这些文件是工程的主体部分,用于实现主框架、文档、视图等。鸡啄米下面分别简单介绍下各个文件:
           HelloWorld.h:应用程序的主头文件。主要包含由CWinAppEx类派生的CHelloWorldApp类的声明,以及CHelloWorldApp类的全局对象theApp的声明。
           HelloWorld.cpp:应用程序的主源文件。主要包含CHelloWorldApp类的实现,CHelloWorldApp类的全局对象theApp的定义等。
           MainFrm.h和MainFrm.cpp:通过这两个文件从CFrameWndEx类派生出CMainFrame类,用于创建主框架、菜单栏、工具栏和状态栏等。
           HelloWorldDoc.h和HelloWorldDoc.cpp:这两个文件从CDocument类派生出文档类CHelloWorldDoc,包含一些用来初始化文档、串行化(保存和装入)文档和调试的成员函数。
           HelloWorldView.h和HelloWorldView.cpp:它们从CView类派生出名为CHelloWorldView的视图类,用来显示和打印文档数据,包含了一些绘图和用于调试的成员函数。
           ClassView.h和ClassView.cpp:由CDockablePane类派生出CClassView类,用于实现应用程序界面左侧面板上的Class View。
           FileView.h和FileView.cpp:由CDockablePane类派生出CFileView类,用于实现应用程序界面左侧面板上的File View。
           OutputWnd.h和OutputWnd.cpp:由CDockablePane类派生出COutputWnd类,用于实现应用程序界面下侧面板Output。
           PropertiesWnd.h和PropertiesWnd.cpp:由CDockablePane类派生出CPropertiesWnd类,用于实现应用程序界面右侧面板Properties。
           ViewTree.h和ViewTree.cpp:由CTreeCtrl类派生出CViewTree类,用于实现出现在ClassView和FileView等中的树视图。
           4.资源文件
           一般我们使用MFC生成窗口程序都会有对话框、图标、菜单等资源,应用程序向导会生成资源相关文件:res目录、HelloWorld.rc文件和Resource.h文件。
           res目录:工程文件夹下的res目录中含有应用程序默认图标、工具栏使用图标等图标文件。
           HelloWorld.rc:包含默认菜单定义、字符串表和加速键表,指定了默认的About对话框和应用程序默认图标文件等。
           Resource.h:含有各种资源的ID定义。
           5.预编译头文件
           几乎所有的MFC程序的文件都要包含afxwin.h等文件,如果每次都编译一次则会大大减慢编译速度。所以把常用的MFC头文件都放到了stdafx.h文件中,然后由stdafx.cpp包含stdafx.h文件,编译器对stdafx.cpp只编译一次,并生成编译之后的预编译头HelloWorld.pch,大大提高了编译效率。
           6.编译链接生成文件
           如果是Debug方式编译,则会在解决方案文件夹和工程文件夹下都生成Debug子文件夹,而如果是Release方式编译则生成Release子文件夹。
           工程文件夹下的Debug或Release子文件夹中包含了编译链接时产生的中间文件,解决方案文件夹下的Debug或Release子文件夹中主要包含有应用程序的可执行文件。
           关于应用程序工程文件的组成结构鸡啄米就先讲到这了。其中包含了很多专有名词,以后大家会慢慢熟悉的。欢迎来鸡啄米博客交流。谢谢。
    View Code

    3.MFC应用程序框架分析

       上一讲鸡啄米讲的是VS2010应用程序工程中文件的组成结构,可能大家对工程的运行原理还是很模糊,理不出头绪,毕竟跟C++编程入门系列中的例程差别太大。这一节鸡啄米就为大家分析下MFC应用程序框架的运行流程。
           一.SDK应用程序与MFC应用程序运行过程的对比
           程序运行都要有入口函数,在之前的C++教程中都是main函数,而Windows应用程序的入口函数是WinMain函数,MFC程序也是从WinMain函数开始的。下面鸡啄米就给出用Windows SDK写的“HelloWorld”程序,与应用程序框架进行对比,这样能更好的了解框架是怎样运行的。Windows SDK开发程序就是不使用MFC类库,直接用Windows API函数进行软件开发。鸡啄米不是要讲解SDK开发,只是为了对比而简单介绍,至于SDK开发可以在大家学完MFC以后选择是否要研究,一般来说有简单了解就可以了。
           SDK应用程序
           首先,给出Windows SDK应用程序“HelloWorld”的源码:  
    C++代码
    #include <windows.h>    
      
    LRESULT CALLBACK myWndProc(HWND hWindow, UINT msg, WPARAM wParam, LPARAM lParam);   
         
    int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, PSTR szCmdLine, int iCmdShow)      
    {      
      const static TCHAR appName[] = TEXT("Hello world");      
      WNDCLASSEX myWin;      
      myWin.cbSize = sizeof(myWin);      
      myWin.style = CS_HREDRAW | CS_VREDRAW;      
      myWin.lpfnWndProc = myWndProc;      
      myWin.cbClsExtra = 0;      
      myWin.cbWndExtra = 0;      
      myWin.hInstance = hInstance;      
      myWin.hIcon = 0;      
      myWin.hIconSm  = 0;      
      myWin.hCursor = 0;      
      myWin.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);      
      myWin.lpszMenuName = 0;      
      myWin.lpszClassName = appName;      
      //Register      
      if (!RegisterClassEx(&myWin)) return 0;      
      const HWND hWindow = CreateWindow(      
        appName,      
        appName,      
        WS_OVERLAPPEDWINDOW,      
        CW_USEDEFAULT,      
        CW_USEDEFAULT,      
        CW_USEDEFAULT,      
        CW_USEDEFAULT,      
        0,      
        0,      
        hInstance,      
        0);      
      ShowWindow(hWindow,iCmdShow);      
      UpdateWindow(hWindow);      
      {      
        MSG msg;      
        while(GetMessage(&msg,0,0,0))      
        {      
          TranslateMessage(&msg);      
          DispatchMessage(&msg);      
        }      
        return (int)msg.wParam;      
      }      
    }      
         
    LRESULT CALLBACK myWndProc(HWND hWindow, UINT msg, WPARAM wParam, LPARAM lParam)      
    {      
      if (msg==WM_PAINT)      
      {      
        PAINTSTRUCT ps;      
        const HDC hDC = BeginPaint(hWindow,&ps);      
        RECT rect;      
        GetClientRect(hWindow,&rect);      
        DrawText(hDC,TEXT("HELLO WORLD"),-1,&rect, DT_SINGLELINE | DT_CENTER | DT_VCENTER);      
        EndPaint(hWindow,&ps);      
        return 0;      
      }      
      else if (msg==WM_DESTROY)      
      {      
        PostQuitMessage(0);      
        return 0;      
      }      
      return DefWindowProc(hWindow,msg,wParam,lParam);      
    }  
           上面的程序运行的流程是:进入WinMain函数->初始化WNDCLASSEX,调用RegisterClassEx函数注册窗口类->调用ShowWindow和UpdateWindow函数显示并更新窗口->进入消息循环。关于消息循环再简单说下,Windows应用程序是消息驱动的,系统或用户让应用程序进行某项操作或完成某个任务时会发送消息,进入程序的消息队列,然后消息循环会将消息队列中的消息取出,交予相应的窗口过程处理,此程序的窗口过程函数就是myWndProc函数,窗口过程函数处理完消息就完成了某项操作或任务。本例是要显示“HELLO WORLD”字符串,UpdateWindow函数会发送WM_PAINT消息,但是此消息不经过消息队列而是直接送到窗口过程处理,在窗口过程函数中最终绘制了“HELLO WORLD”字符串。
    
           MFC应用程序
           下面是MFC应用程序的运行流程,通过MFC库中代码进行分析:
           首先在HelloWorld.cpp中定义全局对象theApp:CHelloWorldApp theApp;。调用CWinApp和CHelloWorldApp的构造函数后,进入WinMain函数(位于appmodul.cpp中)。
    C++代码
    extern "C" int WINAPI   
    _tWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,   
        _In_ LPTSTR lpCmdLine, int nCmdShow)   
    #pragma warning(suppress: 4985)   
    {   
        // call shared/exported WinMain   
        return AfxWinMain(hInstance, hPrevInstance, lpCmdLine, nCmdShow);   
    }  
           在TCHAR.h中,有此定义:#define _tWinMain   WinMain,所以这里的_tWinMain就是WinMain函数。它调用了AfxWinMain函数(位于WinMain.cpp中)。
    C++代码
    int AFXAPI AfxWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,LPTSTR lpCmdLine, int nCmdShow)   
    {    
           .............略   
           // App global initializations (rare)   
           if (pApp != NULL && !pApp->InitApplication())   
                  goto InitFailure;   
      
           if (!pThread->InitInstance())   
           {   
                  .........略   
           }   
      
           // Run函数位于THRDCORE.cpp中,由此函数进入消息循环   
           nReturnCode = pThread->Run();   
      
           ..............略   
      
           return nReturnCode;   
    }   
           上面InitInstance函数的代码如下:
    C++代码
    BOOL CTestApp::InitInstance()        
    {       
           .............略       
           CSingleDocTemplate* pDocTemplate;       
           pDocTemplate = new CSingleDocTemplate(       
                  IDR_MAINFRAME,       
                  RUNTIME_CLASS(CTestDoc),       
                  RUNTIME_CLASS(CMainFrame),      // main SDI frame window       
                  RUNTIME_CLASS(CTestView));     
           if (!pDocTemplate)   
                 return FALSE;     
           AddDocTemplate(pDocTemplate);       
           // Parse command line for standard shell commands, DDE, file open       
          
           CCommandLineInfo cmdInfo;       
           ParseCommandLine(cmdInfo);       
          
           //ProcessShellCommand位于AppUI2.cpp中,注册并创建窗口       
           if (!ProcessShellCommand(cmdInfo))       
                 return FALSE;       
          
           m_pMainWnd->ShowWindow(SW_SHOW);       
           m_pMainWnd->UpdateWindow();       
          
           return TRUE;       
    }      
           InitInstance中的ProcessShellCommand函数又调用了CMainFrame的LoadFrame函数注册并创建了窗口,执行完ProcessShellCommand函数以后,调用了m_pMainWnd的ShowWindow和UpdateWindow函数显示并更新框架窗口。这些是不是与上面的SDK程序十分类似?
           接下来该是消息循环了,上面的AfxWinMain函数中调用了pThread的Run函数(位于THRDCORE.cpp中),在Run中包含了消息循环。Run函数的代码如下:
    C++代码
    int CWinThread::Run()       
    {       
            .............略       
            // phase2: pump messages while available       
            do      
            {       
                  // pump message, but quit on WM_QUIT       
                  if (!PumpMessage())       
                         return ExitInstance();       
          
                  // reset "no idle" state after pumping "normal" message       
                  if (IsIdleMessage(&m_msgCur))       
                  {       
                         bIdle = TRUE;       
          
                         lIdleCount = 0;       
          
                  }       
           } while (::PeekMessage(&m_msgCur, NULL, NULL, NULL, PM_NOREMOVE));       
           ..............略       
    }       
            
    BOOL CWinThread::PumpMessage()       
    {     
           return AfxInternalPumpMessage();    
    }    
      
    BOOL AFXAPI AfxInternalPumpMessage()   
    {   
           _AFX_THREAD_STATE *pState = AfxGetThreadState();   
          
           if (!::GetMessage(&(pState->m_msgCur), NULL, NULL, NULL))          
           {       
                 .............略       
           }       
           ...............略       
           if (pState->m_msgCur.message != WM_KICKIDLE && !AfxPreTranslateMessage(&(pState->m_msgCur)))   
           {   
                 ::TranslateMessage(&(pState->m_msgCur));   
                 ::DispatchMessage(&(pState->m_msgCur));   
           }     
          
           return TRUE;       
    }       
           我们看到PumpMessage中通过调用GetMessage、TranslateMessage、DispatchMessage等建立了消息循环并投递消息。
           窗口过程函数AfxWinProc形式如下:
    C++代码
    LRESULT CALLBACK AfxWndProc(HWND hWnd,UINT nMsg,WPARAM wParam, LPARAM lParam)   
    {   
          ……   
          CWnd*pWnd=CWnd::FromHandlePermanent(hWnd);  
          ReturnAfxCallWndProc(pWnd,hWnd,nMsg,wParam,lParam);   
    }  
           两者运行过程对比
           到此,通过对比可以发现,MFC应用程序的运行流程与SDK程序是类似的,都是先进行一些初始化过程,再注册并创建窗口,然后显示、更新窗口,最后进入消息循环,消息都由窗口过程函数处理。现在大家是不是觉得有些头绪了?在运行流程上有基本的掌握即可。
           二.MFC应用程序框架主要类之间的关系
           在第二讲中,给大家演示了如何利用应用程序向导生成单文档应用程序框架,可以看到程序的基本框架和必要的代码都自动生成了,上一讲又讲解了文件组成结构,实际上在前面自动生成的框架中比较重要的类包括以下几个:CHelloWorldApp、CMainFrame、CHelloWorldDoc和CHelloWorldView,至于其他的类比如CClassView、CFileView等都是在框架窗口(CMainFrame)上创建的面板等,不是必要的。
           鸡啄米就四个主要类的关系简单讲下,CHelloWorldApp类处理消息,将收到的消息分发给相应的对象。CMainFrame是视图CHelloWorldView的父窗口,视图CHelloWorldView就显示在CMainFrame的客户区中。视图类CHelloWorldView用来显示文档类CHelloWorldDoc中的数据,并根据对视图类的操作修改文档类的数据。一个视图类只能跟一个文档类相联系,而一个文档类可以跟多个视图类相联系。关于视图类和文档类的关系后面会详细讲解。
           本节VC++/MFC编程入门教程内容比较多,主要是让大家对MFC应用程序的运行原理有大概的了解。对于以后的MFC开发有很多好处。如果有问题请在鸡啄米博客留言交流。谢谢。
    View Code

    4.MFC消息映射机制概述

    上一讲鸡啄米为大家简单分析了MFC应用程序框架,这一讲是关于MFC消息映射机制的内容。
           前面已经说过,Windows应用程序是消息驱动的。在MFC软件开发中,界面操作或者线程之间通信都会经常用到消息,通过对消息的处理实现相应的操作。比较典型的过程是,用户操作窗口,然后有消息产生,送给窗口的消息处理函数处理,对用户的操作做出响应。
           什么是消息
           窗口消息一般由三个部分组成:1.一个无符号整数,是消息值;(2)消息附带的WPARAM类型的参数;(3)消息附带的LPARAM类型的参数。其实我们一般所说的消息是狭义上的消息值,也就是一个无符号整数,经常被定义为宏。
           什么是消息映射机制
           MFC使用一种消息映射机制来处理消息,在应用程序框架中的表现就是一个消息与消息处理函数一一对应的消息映射表,以及消息处理函数的声明和实现等代码。当窗口接收到消息时,会到消息映射表中查找该消息对应的消息处理函数,然后由消息处理函数进行相应的处理。SDK编程时需要在窗口过程中一一判断消息值进行相应的处理,相比之下MFC的消息映射机制要方便好用的多。
           Windows消息分类
           先讲下Windows消息的分类。Windows消息分为系统消息和用户自定义消息。Windows系统消息有三种:
           1.标准Windows消息。除WM_COMMAND外以WM_开头的消息是标准消息。例如,WM_CREATE、WM_CLOSE。
           2.命令消息。消息名为WM_COMMAND,消息中附带了标识符ID来区分是来自哪个菜单、工具栏按钮或加速键的消息。
           3.通知消息。通知消息一般由列表框等子窗口发送给父窗口,消息名也是WM_COMMAND,其中附带了控件通知码来区分控件。
           CWnd的派生类都可以接收到标准Windows消息、通知消息和命令消息。命令消息还可以由文档类等接收。
           用户自定义消息是实际上就是用户定义一个宏作为消息,此宏的值应该大于等于WM_USER,然后此宏就可以跟系统消息一样使用,窗口类中可以定义它的处理函数。
           消息映射表
           除了一些没有基类的类或CObject的直接派生类外,其他的类都可以自动生成消息映射表。下面的讲解都以前面例程HelloWorld的CMainFrame为例。消息映射表如下:
    C++代码
    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)   
        ON_WM_SETTINGCHANGE()   
    END_MESSAGE_MAP()  
           在BEGIN_MESSAG_MAP和END_MESSAGE_MAP之间的内容成为消息映射入口项。消息映射除了在CMainFrame的实现文件中添加消息映射表外,在类的定义文件MainFrm.h中还会添加一个宏调用:
           DECLARE_MESSAGE_MAP()
           一般这个宏调用写在类定义的结尾处。
    
           添加消息处理函数
           如何添加消息处理函数呢?不管是自动还是手动添加都有三个步骤:
           1.在类定义中加入消息处理函数的函数声明,注意要以afx_msg打头。例如MainFrm.h中WM_CREATE的消息处理函数的函数声明:afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct);。
           2.在类的消息映射表中添加该消息的消息映射入口项。例如WM_CREATE的消息映射入口项:ON_WM_CREATE()。
           3.在类实现中添加消息处理函数的函数实现。例如,MainFrm.cpp中WM_CREATE的消息处理函数的实现:
              int CMainFrame::OnCreate(LPCREATESTRUCT lpCreateStruct)
             {
                      ......
             }
           通过以上三个步骤以后,WM_CREATE等消息就可以在窗口类中被消息处理函数处理了。
           各种Windows消息的消息处理函数
           标准Windows消息的消息处理函数都与WM_CREATE消息类似。
           命令消息的消息映射入口项形式如:ON_COMMAND(ID_VIEW_CUSTOMIZE, &CMainFrame::OnViewCustomize),消息为ID_VIEW_CUSTOMIZE,消息处理函数为OnViewCustomize。
           如果想要使用某个处理函数批量处理某些命令消息,则可以像CMainFrame消息映射表中的ON_COMMAND_RANGE(ID_VIEW_APPLOOK_WIN_2000, ID_VIEW_APPLOOK_WINDOWS_7, &CMainFrame::OnApplicationLook)一样添加消息映射入口项,这样值在ID_VIEW_APPLOOK_WIN_2000到ID_VIEW_APPLOOK_WINDOWS_7之间的菜单项等的命令消息都由CMainFrame的OnApplicationLook函数处理。函数原型为afx_msg void OnApplicationLook(UINT id);,参数id为用户操作的菜单项等的ID。
           在操作列表框等控件时往往会给父窗口发送WM_NOTIFY通知消息。WM_NOTIFY消息的wParam参数为发送通知消息的控件的ID,lParam参数指向一个结构体,可能是NMHDR结构体,也可能是第一个元素为NMHDR结构体变量的其他结构体。NMHDR结构体的定义如下(仅作了解):
           Typedef sturct tagNMHDR{
                    HWND hwndFrom;
                    UINT idFrom;
                    UINT code;
           } NMHDR;
           hwndFrom为发送通知消息控件的句柄,idFrom为控件ID,code为要处理的通知消息的通知码,例如NM_CLICK。
    
           通知消息的消息映射入口项形式如:
           ON_NOTIFY(wNotifyCode,id,memberFxn)
           wNotifyCode为要处理的通知消息通知码,例如:NM_CLICK。id为控件标识ID。MemberFxn为此消息的处理函数。
           通知消息的处理函数的原型为:
           afx_msg void memberFxn( NMHDR * pNotifyStruct, LRESULT * result);
           如果需要使用用户自定义消息,首先要定义消息宏,如:#define WM_UPDATE_WND (WM_USER+1),再到消息映射表中添加消息映射入口项:ON_MESSAGE(WM_UPDATE_WND, &CMainFrame::OnUpdateWnd),然后在MainFrm.h中添加消息处理函数的函数声明:afx_msg LRESULT OnUpdateWnd(WPARAM wParam, LPARAM lParam);,最后在MainFrm.cpp中实现此函数。
           鸡啄米本节对MFC消息映射机制只是做了比较简单的讲解,让大家对它有一定的认识,编程入门者不必强求完全掌握。在以后的教程中会经常涉及到消息的使用,大家会逐渐熟悉MFC的消息映射机制。
    View Code

    第3部分:对话框

    1.对话框:创建对话框模板和修改对话框属性

    鸡啄米在上一讲中介绍了MFC的消息映射机制,属于原理方面的知识。对于VC++编程入门学习者来说可能有些抽象,鸡啄米会把消息映射的知识渗透到后面的教程中。本节开始为大家讲解偏应用的知识-创建对话框。
           对话框,大家应该很熟悉了,在我们常用的软件中大多都有对话框界面,例如,360安全卫士的主界面其实就是个对话框,只是它做了很多美工方面的工作,将其大大美化了。
           创建对话框主要分两大步,第一,创建对话框资源,主要包括创建新的对话框模板、设置对话框属性和为对话框添加各种控件;第二,生成对话框类,主要包括新建对话框类、添加控件变量和控件的消息处理函数等。鸡啄米在本节中先讲讲怎样创建对话框模板和设置对话框属性。
           创建基于对话框的应用程序框架
           之前鸡啄米创建的HelloWorld程序是单文档应用程序,生成了多种窗口,如果用它来将讲创建对话框的话可能有些复杂,对大家单纯理解对话框有点影响,所以这里鸡啄米就再创建一个基于对话框的应用程序,用来实现加法运算的功能。创建步骤同单文档应用程序大同小异,简单步骤如下:
           1.选择菜单项File->New->Project,弹出“New Project”对话框。
           2.左侧面板中Installed Templated的Visual C++下选择MFC,中间窗口中选择MFC Application,然后在下面的Name编辑框中键入工程名称,本例取名“Addition”,在Location编辑框中设置工程的保存路径。点“OK”。
           3.点“Next”到“Application Type”对话框,在Application type下选择Dialog based,其他使用默认设置,点“Finish”。
           我们可以在Solution Explorer视图中看到,此工程的文件要比单文档应用程序少的多,在Class View中主要有三个类:CAboutDlg、CAdditionApp和CAdditionDlg。CAboutDlg是应用程序的“关于”对话框类,CAdditionApp是由CWinApp派生的类,CAdditionDlg是主对话框类,主对话框也就是此应用程序运行后显示的主要界面。
           注:如果在VS2010中找不到Solution Explorer或Class View等视图,可以在菜单项View下找到对应视图选项选择即可。在VS2010的使用介绍中已经有讲解。
           在Resource View视图中可以看到工程Addition的资源树,展开Addition.rc,下面有四个子项:Dialog(对话框)、Icon(图标)、String Table(字符串表)和Version(版本)。然后展开Dialog项,下面有两个对话框模板,其ID分别为:IDD_ABOUTBOX和IDD_ADDITION_DIALOG,前者是“关于”对话框的模板,后者是主对话框的模板。ID是资源的唯一标识,本质上是一个无符号整数,一般ID代表的整数值由系统定义,我们无需干涉。
           对话框模板
           可见对于主对话框来说,创建对话框第一步中的创建新的对话框模板已经由系统自动完成了。而如果是再添加对话框需要创建新的对话框模板时,需要在Resource View的“Dialog”节点上点右键,在右键菜单中选择“Insert Dialog”,就会生成新的对话框模板,并且会自动分配ID。
           在Resource View的资源树中双击某个ID,可在中间区域内显示相应的资源界面。双击IDD_ADDITION_DIALOG时,中间区域就会显示Addition对话框模板。如下图:
    
           设置对话框属性
           在Addition对话框模板上点右键,然后在右键菜单中选择Properties,则在右侧面板中会显示对话框的属性列表。如下图:
    
           鸡啄米在这里对经常使用的几个属性作简单说明,并对Addition对话框进行属性设置说明。
           1.ID:对话框ID,唯一标识对话框资源,可以修改。此处为IDD_ADDITION_DIALOG,我们不修改它。
           2.Caption:对话框标题。此处默认为Addition,我们将其修改为“加法计算器”。
           3.Border:边框类型。有四种类型:None、Thin、Resizing和Dialog Frame。我们使用默认的Dialog Frame。
           4.Maximize:是否使用最大化按钮。我们使用默认的False。
           5.Minimize:是否使用最小化按钮。同样我们使用默认的False。
           6.Style:对话框类型。有三种类型:Overlapped(重叠窗口)、Popup(弹出式窗口)和Child(子窗口)。弹出式窗口比较常见。我们使用默认的Popup类型。
           7.System Menu:是否带有标题栏左上角的系统菜单,包括移动、关闭等菜单项。我们使用默认的True。
           8.Title Bar:是否带有标题栏。我们使用默认的True。
           9.Font(Size):字体类型和字体大小。如果将其修改为非系统字体,则Use System自动改为False。而如果Use System原来为False,将其修改为True,则Font(Size)自动设置为系统字体。这里我们使用默认的系统字体。
           根据以上说明,其实我们只修改了标题属性。这时我们运行此程序后的界面如下:
    
           这一讲就先讲到这里了,对于创建对话框第一步中的为对话框添加各种控件下一讲为大家演示。欢迎来鸡啄米博客交流学习。
    View Code

    2.对话框:为对话框添加控件

    创建对话框资源需要创建对话框模板、修改对话框属性、为对话框添加各种控件等步骤,前面一讲中鸡啄米已经讲了创建对话框模板和修改对话框属性,本节继续讲如何为对话框添加控件。
           上一讲中鸡啄米创建了一个名为“Addition”的工程,目的是生成一个实现加法运算的应用程序。实现加法计算有几个必要的因素:被加数、加数、和。被加数和加数需要输入,和需要输出显示。那么这几个因素都需要相应的控件来输入或显示,下面鸡啄米就一步步讲解如何添加这些控件。
           1.为对话框添加一个静态文本框(Static Text),用于显示字符串--“被加数”。
           上一讲中生成的资源模板中自动添加了一个标题为“TODO:Place dialog controls here.”的静态文本框,我们可以修改它的标题继续使用,也可以删掉它。这里为了从头讲解静态文本框的添加过程,将它删掉,继续添加新的静态文本框。
           删除控件时,可以使用鼠标左键点击选中它,选中后控件的周围会出现虚线框,然后按Delete键就可以将其删除了。在“Addition”工程的Resource View中打开上一讲中创建的对话框模板IDD_ADDITION_DIALOG,自动添加的静态文本框就可以使用这种方法删除。
           在添加新的静态文本框以前,先看看Toolbox视图是否显示了,如果没有显示,在菜单栏上点击View->Toolbox即可。Toolbox视图如下图:
    
           Toolbox中列出了一些常用控件,其中有一个是Static Text,即是我们要添加的控件。在Toolbox中的Static Text上点下鼠标左键不放开,并拖到IDD_ADDITION_DIALOG对话框模板上,模板上会出现一个虚线框,我们找到合适的位置松开鼠标左键放下它。
           用鼠标左键选中控件后周围出现虚线框,然后鼠标移到虚线框上几个黑点的位置会变成双向箭头的形状,此时就可以按下鼠标左键并拖动来改变控件大小了。我们可以这样改变新添加的静态文本框控件的大小,以更好的显示标题。当然,整个对话框模板也可以用这种方法改变大小。
           接下来就该修改静态文本框的文字了。鼠标右键点击静态文本框,在右键菜单中选择“Properties”,Properties面板就会显示出来,在面板上修改Caption属性为“被加数”,ID修改为IDC_SUMMAND_STATIC。此时模板如下图:
    
           2.为对话框添加一个编辑框(Edit Control),用来输入被加数。
           添加编辑框的过程与静态文本框类似,在Toolbox中选中Edit Control控件拖到对话框模板上,并使其与之前的静态文本框水平对齐(为了美观),然后调整其大小使之适合被加数的输入。
           在编辑框上点右键,仍然在右键菜单中选择“Properties”显示出属性(Properties)面板,修改其ID为IDC_SUMMAND_EDIT。此时模板如下图:
    
           3.按照1的方法添加一个标题为“加数”的静态文本框,用于显示字符串--“加数”。并将其ID改为IDC_ADDEND_STATIC。
           4.按照2的方法添加一个ID为IDC_ADDEND_EDIT的编辑框,用来输入加数。
           5.按照1的方法添加一个标题为“和”的静态文本框,用于显示文字--“和”。并修改其ID为IDC_SUM_STATIC。
           6.按照2的方法添加一个ID为IDC_SUM_EDIT的编辑框,用来显示最终的加和。
           7.类似的添加按钮(Button)控件到对话框模板,用于在被点击后触发加法计算。修改其标题为“计算”,ID为IDC_ADD_BUTTON。
           到此,对话框模板如图:
    
           8.删除OK按钮。打开Cancel按钮的属性面板,将标题改为“退出”,并使其与“计算”按钮水平对齐。
           9.根据控件的布局,适当调整整个对话框模板的大小,使其相对控件布局来说大小合适,界面美观。
           这样在对话框模板中就把我们在本例中需要用到的控件就添加完了。最终效果如下:
    
           至此,我们的对话框资源就基本创建完了。应用程序运行后的界面效果已经很清楚了。后面鸡啄米会讲如何在对话框类中实现加法计算功能,并能很好的和界面交互。欢迎继续到鸡啄米博客交流。
    View Code

    3.对话框:创建对话框类和添加控件变量

    前两讲中鸡啄米为大家讲解了如何创建对话框资源。创建好对话框资源后要做的就是生成对话框类了。鸡啄米再声明下,生成对话框类主要包括新建对话框类、添加控件变量和控件的消息处理函数等。
           因为鸡啄米给大家的例程Addition是基于对话框的程序,所以程序自动创建了对话框模板IDD_ADDITION_DIALOG,并自动生成了对话框类CAdditionDlg,它是从CDialogEx类派生的。大家用过VC++ 6.0的可能记得,我们定义的对话框类都是从CDialog类派生的,但在VS2010中,一般对话框类都是继承自CDialogEx类。
           创建对话框类
           如果是自己新添加的对话框模板,怎样为它创建对话框类呢?
           1.首先鸡啄米就按第六讲:创建对话框模板和修改对话框属性中说的那样,在Resource View的“Dialog”节点上右键,然后在右键菜单中选择“Insert Dialog”创建一个新的对话框模板,ID就使用默认的IDD_DIALOG1。
           2.在中间区域会显示新建的对话框模板,然后选中此对话框模板,点右键,在右键菜单中选择Add Class。
     
    
           3.选择“Add Class”后会弹出一个对话框,在对话框中“Class name”下的编辑框中写入自定义的类名就可以了,例如CMyDialog。
           4.最后点“Finish”完成。
           最终你就可以在Class View中看到新生成的对话框类CMyDialog了,并且在Solution Explorer中有相应的MyDialog.h头文件和MyDialog.cpp源文件生成。CMyDialog类同样派生于CDialogEx类。
           注意,一般类名都以C打头,又比如,CTestDlg。
           为对话框中的控件添加变量
           在上一讲中为对话框添加了几个控件,包括三个静态文本框,三个编辑框,一个按钮控件。程序自动生成的Cancel按钮保留,作为退出按钮,而OK按钮删除掉了。
           静态文本框只是为了说明后面紧跟的编辑框中数据的意义,是被加数、加数还是和,所以它们是不会变的,我们就不为它们添加变量了。按钮控件是用来操作的,这里也不为它们添加变量。编辑框中的数据可能会经常变化,有必要为它们每个控件关联一个变量。
           首先为被加数的编辑框IDC_SUMMAND_EDIT添加变量。
           1.在编辑框上点右键,在右键菜单中选择“Add Variable”。弹出添加成员变量的向导对话框。
           2.我们想为其添加值变量而不是控件变量,所以对话框中“Category”下的组合框中选择Value。
           3.“Variable type”下的组合框此时默认选中的是“CString”,CString是字符串类,显然不能进行加法运算。我们可以选择double、float、int等。这里我们选择double,即编辑框关联一个double类型的变量。
           4.在“Variable name”中写入自定义的变量名。鸡啄米为其取名m_editSummand。
    
           5.点“Finish”完成。
           注意,类的成员变量名一般以m_打头,以标识它是一个成员变量。
           参照此方法,再分别为加数的编辑框IDD_ADDEND_EDIT添加double型变量m_editAddend、和的编辑框IDD_SUM_EDIT添加double型变量m_editSum。
           对话框类的数据交换和检验
           在程序运行界面中,用户往往会改变控件的属性,例如,在编辑框中输入字符串,或者改变组合框的选中项,又或者改变复选框的选中状态等。控件的属性改变后MFC会相应修改控件关联变量的值。这种同步的改变是通过MFC为对话框类自动生成的成员函数DoDataExchange()来实现的,这也叫做对话框的数据交换和检验机制。
           我们为三个编辑框添加了变量以后,在AdditionDlg.cpp中CAdditionDlg的DoDataExchange()函数的函数体中多了三条DDX_Text调用语句。下面是函数体代码和鸡啄米添加的注释。
    C++代码
    void CAdditionDlg::DoDataExchange(CDataExchange* pDX)   
    {   
        // 处理MFC默认的数据交换   
        CDialogEx::DoDataExchange(pDX);   
        // 处理控件IDC_SUMMAND_EDIT和变量m_editSummand之间的数据交换   
        DDX_Text(pDX, IDC_SUMMAND_EDIT, m_editSummand);   
        // 处理控件IDC_ADDEND_EDIT和变量m_editAddend之间的数据交换   
        DDX_Text(pDX, IDC_ADDEND_EDIT, m_editAddend);   
        // 处理控件IDC_SUM_EDIT和变量m_editSum之间的数据交换   
        DDX_Text(pDX, IDC_SUM_EDIT, m_editSum);   
    }  
           鸡啄米再以Addition程序为例简单说下数据交换机制。如果我们在程序运行界面中输入被加数,则通过CAddition的DoDataExchange()函数可以将输入的值保存到m_editSummand变量中,反之如果程序运行中修改了变量m_editSummand的值,则通过CAddition的DoDataExchange()函数也可以将新的变量值显示到被加数的编辑框中。
           但是这种数据交换机制中,DoDataExchange()并不是被自动调用的,而是需要我们在程序中调用CDialogEx::UpdateData()函数,由UpdateData()函数再去自动调用DoDataExchange()的。
           CDialogEx::UpdateData()函数的原型为:
           BOOL UpdateData(BOOL bSaveAndValidate = TRUE);
           参数:bSaveAndValidate用于指示数据传输的方向,TRUE表示从控件传给变量,FALSE表示从变量传给控件。默认值是TRUE,即从控件传给变量。
           返回值:CDialogEx::UpdateData()函数的返回值表示操作是否成功,成功则返回TRUE,否则返回FALSE。
           在下一讲中鸡啄米将具体演示CDialogEx::UpdateData()函数如何使用。
           鸡啄米本节主要讲的是新建对话框类和添加控件变量,控件的消息处理函数将在下一讲详细介绍。依然欢迎大家常回鸡啄米博客学习和讨论。
    View Code

    4.对话框:为控件添加消息处理函数

     创建对话框类和添加控件变量在上一讲中已经讲过,这一讲的主要内容是如何为控件添加消息处理函数。
           MFC为对话框和控件等定义了诸多消息,我们对它们操作时会触发消息,这些消息最终由消息处理函数处理。比如我们点击按钮时就会产生BN_CLICKED消息,修改编辑框内容时会产生EN_CHANGE消息等。一般为了让某种操作达到效果,我们只需要实现某个消息的消息处理函数。
           一.添加消息处理函数
           鸡啄米仍以前面的加法计算器的程序为例,说明怎样为“计算”按钮控件添加消息处理函数。添加方法列出4种:
           1.使用Class Wizard添加消息处理函数
           用过的VC++ 6.0的朋友应该对Class Wizard很熟悉了,添加类、消息处理函数等经常会用到它,可以说是一个很核心的功能。但从VS2002开始就见不到Class Wizard了,大部分功能都集成到对话框和控件等的属性中了,使用很方便。到VS2010,久违的Class Wizard又回来了。但鸡啄米已经习惯了使用属性中的功能了,对于从VC++ 6.0直接转VS2010的朋友可能觉得还是使用Class Wizard比较习惯。
    
           大家应该记得,“计算”按钮的ID为IDC_ADD_BUTTON,上图中Commands标签下,Oject IDs列表中有此ID,因为我们是想实现点击按钮后的消息处理函数,所以在Messages列表中选择BN_CLICKED消息,然后点右上方的Add Handler就可以添加BN_CLICKED消息处理函数OnClickedAddButton了。当然你也可以改名,但一般用的默认的就可以。
           2.通过“Add Event Handler...”添加消息处理函数
           在“计算”按钮上点右键,然后在右键菜单中选择菜单项“Add Event Handler...”,弹出“Event Handler Wizard”对话框,如下图:
    
           可见“Message type”中默认选中的就是BN_CLICKED消息,函数名和所在类都已经自动给出,直接点“Add and Edit”就可以了。
           3.在按钮的属性视图中添加消息处理函数
           上面说过,从VS2002开始就主要从属性视图添加消息处理函数了。我们在“计算”按钮上点右键,在右键菜单中选择“Properties”,右侧面板中会显示按钮的属性视图。
    
           我们可以像上图中那样,点属性视图的“Control Events”按钮(类似闪电标志),下面列出了“计算”按钮的所有消息。我们要处理的是BN_CLICKED消息,点其右侧空白列表项,会出现一个带下箭头的按钮,再点此按钮会出现“<Add> OnBnClickedAddButton”选项,最后选中这个选项就会自动添加BN_CLICKED处理函数了。
           4.双击按钮添加消息处理函数
           最直接最简单的方法就是,双击“计算”按钮,MFC会自动为其在CAdditionDlg类中添加BN_CLICKED消息的处理函数OnBnClickedAddButton()。
           二.在消息处理函数中添加自定义功能
           在我们使用任意一种方法添加了消息处理函数以后,都只能得到一个空的OnBnClickedAddButton()函数的函数体,要实现我们想要的功能,还需要在函数体中加入自定义功能代码。
           在加法计算器程序中,我们想要“计算”按钮实现的功能是,获取被加数和加数的数值,然后计算它们的和并显示到和的编辑框里。那么,OnBnClickedAddButton()的函数体就应修改为:
    C++代码
    void CAdditionDlg::OnBnClickedAddButton()   
    {   
        // TODO: Add your control notification handler code here   
        // 将各控件中的数据保存到相应的变量   
        UpdateData(TRUE);   
      
        // 将被加数和加数的加和赋值给m_editSum   
        m_editSum = m_editSummand + m_editAddend;   
      
        // 根据各变量的值更新相应的控件。和的编辑框会显示m_editSum的值   
        UpdateData(FALSE);   
    }  
           鸡啄米在上面的代码中已经添加注释,大家应该很容易理解了。对于UpdateData()函数的说明在上一讲中已经介绍过,如果忘了可以再回上一讲了解了解。
           接下来我们运行下此应用程序。在运行结果界面中,输入被加数5.1,加数2.3,然后点“计算”:
    
           在上图中可以看到,点“计算”按钮后,和的编辑框中显示了正确结果:7.4。
           鸡啄米简单分析下运行过程:输入被加数和加数,点“计算”按钮后产生点击消息,从而调用OnBnClickedAddButton()函数。进入此函数后,首先由UpdateData(TRUE)函数将被加数的值5.1和加数的值2.3分别保存到变量m_editSummand和m_editAddend,然后通过语句m_editSum = m_editSummand + m_editAddend;计算出被加数和加数的和为7.4,并把7.4赋值给m_editSum。最后调用UpdateData(FALSE)根据被加数、加数、和的值更新三个编辑框的显示值,就得到了上图中的结果。
           到此,一个具有简单的加法运算功能的加法计算器应用程序就基本完成了。如果大家想实现其他功能,可以修改控件资源和消息处理函数来练习下。本节就讲到这里了,有问题欢迎到鸡啄米博客或者我们的编程入门qq群讨论。
    View Code

    5.对话框:设置对话框控件的Tab顺序

    前面几节鸡啄米为大家演示了加法计算器程序完整的编写过程,本节主要讲对话框上控件的Tab顺序如何调整。
           上一讲为“计算”按钮添加了消息处理函数后,加法计算器已经能够进行浮点数的加法运算。但是还有个遗留的小问题,就是对话框控件的Tab顺序问题。
           运行加法计算器程序,显示对话框后不进行任何操作,直接按回车,可以看到对话框退出了。这是因为“退出”按钮是Tab顺序为1的控件,也就是第一个接受用户输入的控件。但是按照我们的输入习惯,应该是被加数的编辑框首先接受用户输入,然后是加数编辑框,再接下来是“计算”按钮,最后才是“退出”按钮。
           我们先来直观的看看各个控件的Tab顺序吧。打开“Resource View”视图,然后在资源中找到对话框IDD_ADDITION_DIALOG,双击ID后中间客户区域出现其模板视图。在主菜单中选择“Format”->"Tab Order",或者按快捷键Ctrl+D,对话框模板上就会显示各个控件的Tab顺序数字。如下图:
    
           上图中每个控件左上角都有一个数字,这就是它的Tab响应顺序。对话框刚打开时输入焦点就在Tab顺序为1的“退出”按钮上,不做任何操作按下Tab键,输入焦点就会转移到Tab顺序为2的“被加数”静态文本框上,但是因为静态文本框不接受任何输入,所以输入焦点继续自动转移到Tab顺序为3的被加数编辑框,再按Tab键,输入焦点又会转移到Tab顺序为4的“加数”静态文本框上,同样由于它是静态文本框,输入焦点不停留继续转移到加数编辑框,后面的控件同理。
           我们认为这个顺序不合理,那怎么修改呢?很简单,从自己认为Tab顺序应该为1的控件开始依次单击,随着单击的完成,各控件的Tab响应顺序也按我们的想法设置好了。
           例如,此例中我们可以依次单击被加数编辑框、“被加数”静态文本框、加数编辑框、“加数”静态文本框、和编辑框、“和”静态文本框、“计算”按钮和“退出”按钮。设置完后如下图:
    
           最后按ESC键,确认设置并退出对话框模板的Tab顺序设置状态。
           现在我们再运行程序,可以看到对话框打开后最初的输入焦点在被加数编辑框上,然后我们按Tab键,输入焦点移到加数编辑框上,继续多次按Tab键时,输入焦点会按“和编辑框--‘计算’按钮--‘退出’按钮--被加数编辑框--加数编辑框--和编辑框......”的顺序循环转移。这样就达到了我们的目的。
           本节教程内容比较简单,相信大家很快就能掌握。依然欢迎大家在鸡啄米博客留言或到我们的编程入门群讨论。
    View Code

    6.对话框:模态对话框及其弹出过程

    加法计算器对话框程序大家照着做一遍后,相信对基于对话框的程序有些了解了,有个好的开始对于以后的学习大有裨益。趁热打铁,鸡啄米这一节讲讲什么是模态对话框和非模态对话框,以及模态对话框怎样弹出。
           一.模态对话框和非模态对话框
           Windows对话框分为两类:模态对话框和非模态对话框。
           模态对话框是这样的对话框,当它弹出后,本应用程序其他窗口将不再接受用户输入,只有该对话框响应用户输入,在对它进行相应操作退出后,其他窗口才能继续与用户交互。
           非模态对话框则是,它弹出后,本程序其他窗口仍能响应用户输入。非模态对话框一般用来显示提示信息等。
           大家对Windows系统很了解,相信这两种对话框应该都遇到过。之前的加法计算器对话框其实就是模态对话框。
           二.模态对话框是怎样弹出的
           毕竟加法计算器程序大部分都是MFC自动生成的,对话框怎么弹出来的大家可能还不是很清楚。鸡啄米下面简单说说它是在哪里弹出来的,再重新建一个新的对话框并弹出它,这样大家实践以后就能更灵活的使用模态对话框了。
           大家打开Addition.cpp文件,可以看到CAdditionApp类有个InitInstance()函数,在MFC应用程序框架分析中提到过此函数,不过那是单文档应用程序App类中的,函数体不太相同,但都是进行App类实例的初始化工作。
    
           InitInstance()函数的后半部分有一段代码就是定义对话框对象并弹出对话框的,鸡啄米下面给出这段代码并加以注释:
    C++代码
    CAdditionDlg dlg;        // 定义对话框类CAdditionDlg的对象dlg   
    m_pMainWnd = &dlg;       // 将dlg设为主窗口   
    INT_PTR nResponse = dlg.DoModal();   // 弹出对话框dlg,并将DoModal函数的返回值(退出时点击按钮的ID)赋值给nResponse   
    if (nResponse == IDOK)               // 判断返回值是否为OK按钮(其ID为IDOK,鸡啄米已经将它删除)   
    {   
        // TODO: Place code here to handle when the dialog is   
        //  dismissed with OK   
    }   
    else if (nResponse == IDCANCEL)      // 判断返回值是否为Cancel按钮(其ID为IDCANCEL,鸡啄米将它的Caption改为了“退出”)   
    {   
        // TODO: Place code here to handle when the dialog is   
        //  dismissed with Cancel   
    }  
           弹出对话框比较关键的一个函数,就是对话框类的DoModal()函数。CDialog::DoModal()函数的原型为:
           virtual INT_PTR DoModal();   
           返回值:整数值,指定了传递给CDialog::EndDialog(该函数用于关闭对话框)的nResult参数值。如果函数不能创建对话框,则返回-1;如果出现其它错误,则返回IDABORT。
           调用了它对话框就会弹出,返回值是退出对话框时所点的按钮的ID,比如,我们点了“退出”按钮,那么DoModal返回值为IDCANCEL。
           三.添加一个新对话框并弹出它
           鸡啄米再为加法计算器程序添加一个对话框,以在计算之前询问用户是否确定要进行计算。大家可以完整的看下对话框的添加和弹出过程。
           1.根据“创建对话框模板和修改对话框属性”中所讲的方法,在Resource View中的“Dialog”上点右键选择“Insert Dialog”,创建一个新的对话框模板,修改其ID为IDD_TIP_DIALOG,Caption改为“提示”,然后参考“为对话框添加控件”中所讲,在对话框模板上添加一个静态文本框(static text),Caption改为“您确定要进行加法计算吗?”,接下来修改OK按钮的Caption为“确定”,Cancel按钮的Caption为“取消”,最后调整各个控件的位置和对话框的大小。最终的对话框模板如下图:
    
           2.根据“创建对话框类和添加控件变量”中创建对话框类的方法,在对话框模板上点右键选择“Add Class...”,弹出添加类的对话框,设置“Class name”为CTipDlg,点“OK”。在Solution Explorer中可以看到生成了CTipDlg类的头文件TipDlg.h和源文件TipDlg.cpp。
           3.我们要在点“计算”按钮之后弹出此提示对话框,那么就要在“计算”按钮的消息处理函数OnBnClickedAddButton()中访问提示对话框类,所以为了访问CTipDlg类,在AdditionDlg.cpp中包含CTipDlg的头文件:#include "TipDlg.h"4.修改OnBnClickedAddButton()的函数体,在所有代码前,构造CTipDlg类的对象tipDlg,并通过语句tipDlg.DoModal();弹出对话框,最后判断DoModal()函数的返回值是IDOK还是IDCANCEL来确定是否继续进行计算。OnBnClickedAddButton()函数修改后如下:
    C++代码
    void CAdditionDlg::OnBnClickedAddButton()   
    {   
        // TODO: Add your control notification handler code here   
        INT_PTR nRes;             // 用于保存DoModal函数的返回值   
      
        CTipDlg tipDlg;           // 构造对话框类CTipDlg的实例   
        nRes = tipDlg.DoModal();  // 弹出对话框   
        if (IDCANCEL == nRes)     // 判断对话框退出后返回值是否为IDCANCEL,如果是则return,否则继续向下执行   
            return;   
      
        // 将各控件中的数据保存到相应的变量   
        UpdateData(TRUE);   
      
        // 将被加数和加数的加和赋值给m_editSum   
        m_editSum = m_editSummand + m_editAddend;   
      
        // 根据各变量的值更新相应的控件。和的编辑框会显示m_editSum的值   
        UpdateData(FALSE);   
    }  
           5.测试。编译运行程序后,在对话框上输入被加数和加数,点“计算”,弹出提示对话框询问是否进行计算,如果选择“确定”,则提示对话框退出,并在主对话框上显示被加数和加数的和,而如果选择“取消”,则提示对话框也会退出,但主对话框显示的和不变,即没有进行加法计算。
           到此,大家对于模态对话框的基本使用方法应该掌握了吧。希望大家继续关注鸡啄米的MFC教程,我们共同进步。
    View Code

    7.对话框:非模态对话框的创建及显示

    上一节鸡啄米讲了模态对话框及其弹出过程,本节接着讲另一种对话框--非模态对话框的创建及显示。
           鸡啄米已经说过,非模态对话框显示后,程序其他窗口仍能正常运行,可以响应用户输入,还可以相互切换。鸡啄米会将上一讲中创建的Tip模态对话框改为非模态对话框,让大家看下效果。
           非模态对话框的对话框资源和对话框类
           实际上,模态对话框和非模态对话框在创建对话框资源和生成对话框类上是没有区别的,所以上一讲中创建的IDD_TIP_DIALOG对话框资源和CTipDlg类都不需要修改。
           创建及显示非模态对话框的步骤
           需要修改的是,对话框类实例的创建和显示,也就是之前在CAdditionDlg::OnBnClickedAddButton()函数体中添加的对话框显示代码。下面是具体步骤:
           1.在AdditionDlg.h中包含CTipDlg头文件并定义CTipDlg类型的指针成员变量。详细操作方法是,在AdditionDlg.cpp中删除之前添加的#include "TipDlg.h",而在AdditionDlg.h中添加#include "TipDlg.h",这是因为我们需要在AdditionDlg.h中定义CTipDlg类型的指针变量,所以要先包含它的头文件;然后在AdditionDlg.h中为CAdditionDlg类添加private成员变量CTipDlg  *m_pTipDlg;。
           2.在CAdditionDlg类的构造函数中初始化成员变量m_pTipDlg。如果cpp文件中函数太多,我们可以在Class View上半个视图中找到CAdditionDlg类,再在下半个视图中找到其构造函数双击,中间客户区域即可马上切到构造函数的实现处。在构造函数体中添加m_pTipDlg = NULL;,这是个好习惯,鸡啄米在C++编程入门系列的指针的赋值和指针运算中说到过,在任何指针变量使用前都初始化,可以避免因误访问重要内存地址而破坏此地址的数据。
    
           3.将上一讲中添加的模态对话框显示代码注释或删除掉,添加非模态对话框的创建和显示代码。VC++中注释单行代码使用“//”,注释多行代码可以在需注释的代码开始处添加“/*”,结束处添加“*/”。修改后的CAdditionDlg::OnBnClickedAddButton()函数如下:
    C++代码
    void CAdditionDlg::OnBnClickedAddButton()   
    {   
        // TODO: Add your control notification handler code here   
        /*INT_PTR nRes;             // 用于保存DoModal函数的返回值  
     
        CTipDlg tipDlg;           // 构造对话框类CTipDlg的实例  
        nRes = tipDlg.DoModal();  // 弹出对话框  
        if (IDCANCEL == nRes)     // 判断对话框退出后返回值是否为IDCANCEL,如果是则return,否则继续向下执行  
            return;*/  
      
        // 如果指针变量m_pTipDlg的值为NULL,则对话框还未创建,需要动态创建   
        if (NULL == m_pTipDlg)   
        {   
            // 创建非模态对话框实例   
            m_pTipDlg = new CTipDlg();   
            m_pTipDlg->Create(IDD_TIP_DIALOG, this);   
        }   
        // 显示非模态对话框   
        m_pTipDlg->ShowWindow(SW_SHOW);   
      
        // 将各控件中的数据保存到相应的变量   
        UpdateData(TRUE);   
      
        // 将被加数和加数的加和赋值给m_editSum   
        m_editSum = m_editSummand + m_editAddend;   
      
        // 根据各变量的值更新相应的控件。和的编辑框会显示m_editSum的值   
        UpdateData(FALSE);   
    }  
           4.因为此非模态对话框实例是动态创建的,所以需要手动删除此动态对象来销毁对话框。我们在CAdditionDlg类的析构函数中添加删除代码,但是MFC并没有自动给出析构函数,这时需要我们手动添加,在对话框对象析构时就会调用我们自定义的析构函数了。在AdditionDlg.h文件中为CAdditionDlg添加析构函数声明:~CAdditionDlg();,然后在AdditionDlg.cpp文件中添加析构函数的实现,函数体如下:
    C++代码
    CAdditionDlg::~CAdditionDlg()   
    {   
        // 如果非模态对话框已经创建则删除它   
        if (NULL != m_pTipDlg)   
        {   
            // 删除非模态对话框对象   
            delete m_pTipDlg;   
        }   
    }  
           这样,非模态对话框创建和显示的代码就添加修改完了。让我们运行下看看效果吧。
           在加法计算器对话框上输入被加数和加数,然后点“计算”按钮,依然像上节一样弹出了提示对话框,但是先不要关闭它,你可以拖动它后面的加法计算器对话框试试,我们发现加法计算器对话框竟然可以拖动了,而且“和”编辑框里已经显示了运算结果,这表明提示对话框显示以后还没有关闭,OnBnClickedAddButton() 就继续向下执行了,不仅如此,加法计算器的每个编辑框还都可以响应输入。
           这只是一个简单的例子,非模态对话框的用处有很多,以后大家在软件开发中会用到。
           本节教程就到这里了,相信大家对对话框的使用更上了一个台阶了,在不同的情况下可以选择使用模态对话框和非模态对话框了。鸡啄米欢迎大家留言讨论。
    View Code

    8.对话框:属性页对话框及相关类的介绍

    前面讲了模态对话框和非模态对话框,本节开始鸡啄米讲一种特殊的对话框--属性页对话框。另外,本套教程所讲大部分对VC++各个版本均可适用或者稍作修改即可,但考虑到终究还是基于VS2010版本的,所以将《VC++/MFC编程入门》改为《VS2010/MFC编程入门》。
           属性页对话框的分类
           属性页对话框想必大家并不陌生,XP系统中桌面右键点属性,弹出的就是属性页对话框,它通过标签切换各个页面。另外,我们在创建MFC工程时使用的向导对话框也属于属性页对话框,它通过点击“Next”等按钮来切换页面。
           属性页对话框就是包含一般属性页对话框和向导对话框两类。它将多个对话框集成于一身,通过标签或按钮来切换页面。
           属性页对话框相关类
          我们使用属性页对话框时,用到的类主要有两个:CPropertyPage类和CPropertySheet类。
           1.CPropertyPage类
           CPropertyPage类继承自CDialog类,它被用于处理某单个的属性页,所以要为每个属性页都创建一个继承自CPropertyPage的子类。大家可以在VS2010的MSDN中查找CPropertyPage类以及它的成员的详细说明。下面鸡啄米就为大家讲解MSDN中列出的CPropertyPage类的部分主要成员函数。
           (1)构造函数
            这里讲三个CProperty类的构造函数,函数原型为:
            CPropertyPage( );
            explicit CPropertyPage(
                    UINT nIDTemplate,
                    UINT nIDCaption = 0,
                    DWORD dwSize = sizeof(PROPSHEETPAGE)
            );
            explicit CPropertyPage(
                    LPCTSTR lpszTemplateName,
                    UINT nIDCaption = 0,
                    DWORD dwSize = sizeof(PROPSHEETPAGE)
            );
           第一个是没有任何参数的构造函数。
           第二个构造函数中,参数nIDTemplate是属性页的对话框资源ID,参数nIDCaption是属性页对话框选项卡的标题所用字符串资源的ID,若设为0,则选项卡标题就使用该属性页的对话框资源的标题。
           第三个构造函数中,参数lpszTemplateName为属性页的对话框资源的名称字符串,不能为NULL。参数nIDCaption同上。
          (2)CancelToClose()函数
           在模态属性页对话框的属性页进行了某不可恢复的操作后,使用CancelToClose()函数将“OK”按钮改为“Close”按钮,并禁用“Cancel”按钮。函数原型为:
           void CancelToClose( );
          (3)SetModified()函数
           调用此函数可激活或禁用“Apply”按钮,函数原型为:
           void SetModified(BOOL bChanged = TRUE);
          (4)可重载函数
           CPropertyPage类提供了一些消息处理函数,来响应属性页对话框的各种消息。我们重载这些消息处理函数,就可以自定义对属性页对话框操作的处理。可重载的消息处理函数包括:
           OnApply:处理属性页的“Apply”按钮被单击的消息
           OnCancel:处理属性页的“Cancel”按钮被单击的消息
           OnKillActive:处理属性页当前活动状态被切换的消息,常用于数据验证
           OnOK:处理属性页的“OK”按钮、“Apply”按钮或者“Close”按钮被单击的消息
           OnQueryCancel:处理属性页的“Cancel”按钮被单击前发出的消息
           OnReset:处理属性页的“Reset”按钮被单击的消息
           OnSetActive:处理属性页被切换为当前活动页的消息
           OnWizardBack:处理属性页的“Back”按钮被单击的消息,仅在向导对话框中有效
           OnWizardFinish:处理属性页的“Finish”按钮被单击的消息,仅在向导对话框中有效
           OnWizardNext:处理属性页的“Next”按钮被单击的消息,仅在向导对话框中有效
    
           2.CPropertySheet类
           CPropertySheet类继承自CWnd类,它是属性表类,负责加载、打开或删除属性页,并可以在属性页对话框中切换属性页。它跟对话框类似,也有模态和非模态两种。下面鸡啄米就讲解CPropertySheet类的部分成员函数。
          (1)构造函数
           这里依然列出CPropertySheet类的三个构造函数:
           CPropertySheet( );
           explicit CPropertySheet(
                   UINT nIDCaption,
                   CWnd* pParentWnd = NULL,
                   UINT iSelectPage = 0 
           );
           explicit CPropertySheet(
                   LPCTSTR pszCaption,
                   CWnd* pParentWnd = NULL,
                   UINT iSelectPage = 0 
           );
           参数nIDCaption:标题的字符串资源的ID。
           参数pParentWnd:属性页对话框的父窗口,若设为NULL,则父窗口为应用程序的主窗口。
           参数iSelectPage:初始状态时,活动属性页的索引,默认为第一个添加到属性表的属性页。
           参数pszCaption:标题字符串。
          (2)GetActiveIndex()函数
           获取当前活动属性页的索引。函数原型为:
           int GetActiveIndex( ) const;
           返回值:当前活动属性页的索引。
          (3)GetActivePage()函数
           获取当前活动属性页对象。函数原型为:
           CPropertyPage* GetActivePage( ) const;
           返回值:当前活动属性页对象的指针。
          (4)GetPage()函数
           获取某个属性页对象。函数原型为:
           CPropertyPage* GetPage(int nPage) const;
           参数nPage:目标属性页的索引。
           返回值:目标属性页对象的指针。
          (5)GetPageCount()函数
           获取属性页的数量。函数原型为:
           int GetPageCount( ) const;
           返回值:属性页的数量。
          (6)GetPageIndex()函数
           获取某属性页在属性页对话框中的索引。函数原型为:
           int GetPageIndex(CPropertyPage* pPage);
           参数pPage:要获取索引的属性页对象的指针。
           返回值:属性页对象在属性页对话框中的索引。
          (7)SetActivePage()函数
           设置某个属性页为活动属性页。函数原型为:   
           BOOL SetActivePage(
                     int nPage 
           );
           BOOL SetActivePage(
                     CPropertyPage* pPage 
           );
           参数nPage:要设置为活动属性页的索引。
           参数pPage:要设置为活动属性页的对象指针。
          (8)SetWizardButtons()函数
           在向导对话框上启用或禁用Back、Next或Finish按钮,应在调用DoModal之前调用此函数。函数原型为:
           void SetWizardButtons(
                    DWORD dwFlags 
           );
           参数dwFlags:设置向导按钮的外观和功能属性。可以是以下值的组合:
           PSWIZB_BACK                    启用“Back”按钮,如果不包含此值则禁用“Back”按钮。
           PSWIZB_NEXT                    启用“Next”按钮,如果不包含此值则禁用“Next”按钮。
           PSWIZB_FINISH                  启用“Finish”按钮。
           PSWIZB_DISABLEDFINISH   显示禁用的“Finish”按钮。
          (9)SetWizardMode()函数
           设置属性页对话框为向导对话框模式,应在调用DoModal之前调用此函数。函数原型为:
           void SetWizardMode( );
          (10)SetTitle()函数
           设置属性对话框的标题。函数原型为:
           void SetTitle(
                   LPCTSTR lpszText,
                   UINT nStyle = 0 
           );
           参数lpszText:标题字符串。
           参数nStyle:指定属性表标题的风格。应当为0或PSH_PROPTITLE。如果设为PSH_PROPTITLE,则单词“Properties”会出现在指定标题之后。例如,SetTitle("Simple",PSH_PROPTITLE)这种调用会使得属性表标题为“Simple Properties”。
          (11)AddPage()函数
           为属性对话框添加新的属性页。函数原型为:
           void AddPage(
                   CPropertyPage *pPage 
           );
           参数pPage:要添加的新的属性页的对象指针。
          (12)PressButton()函数
           模拟按下某指定的按钮。函数原型为:   
           void PressButton(
                   int nButton 
           );
           参数nButton:要模拟按下的按钮,它可以是下列值之一:
           PSBTN_BACK   选择“Back”按钮。 
           PSBTN_NEXT   选择“Next”按钮。
           PSBTN_FINISH   选择“Finish”按钮。
           PSBTN_OK   选择“OK”按钮。
           PSBTN_APPLYNOW   选择“Apply”按钮。
           PSBTN_CANCEL   选择“Cancel”按钮。
           PSBTN_HELP   选择“帮助”按钮。
          (13)RemovePage()函数
           删除某属性页。函数原型为:
           void RemovePage(
                   CPropertyPage *pPage 
           );
           void RemovePage(
                   int nPage 
           );
           参数pPage:要删除的属性页的对象指针。
           参数nPage:要删除的属性页的索引。
           属性对话框和相关的两个类鸡啄米就先介绍到这,主要是为后面使用属性页对话框做准备。有问题可以到鸡啄米博客交流。谢谢。
    View Code

    9.对话框:向导对话框的创建及显示

    上一讲鸡啄米讲了属性页对话框和相关的两个类CPropertyPage类和CPropertySheet类,对使用属性页对话框做准备。本节将为大家演示如何创建向导对话框。
           仍然以前面的“加法计算器”的例子为基础,在其中加入向导对话框,我们可以用它来说明加法计算器的使用方法,一步一步引导用户操作,这也是比较常见的用法。
           加法计算器使用时大概可以分为三步:输入被加数、输入加数、点“计算”按钮。
           鸡啄米就详细说明向导对话框的创建步骤:
           1.创建属性页对话框资源
           根据创建对话框模板和修改对话框属性中所讲方法,在“Resource View”的Dialog”节点上点右键,然后在右键菜单中选择“Insert Dialog”创建第一个对话框模板,对话框的ID属性设置为IDD_SUMMAND_PAGE,Caption属性改为“被加数页”,Style属性在下拉列表中选择“Child”,Border属性在下拉列表中选择“Thin”。
           删除“OK”和“Cancel”按钮,再按照为对话框添加控件中所讲方法,添加一个静态文本框,并修改静态文本框的Caption属性为“请先输入double型被加数”。
           按照上述步骤,继续添加第二个和第三个对话框资源。第二个对话框模板的ID设为IDD_ADDEND_PAGE,Caption属性改为“加数页”,也添加一个静态文本框,Caption设为“请继续输入double型加数”,其他属性同第一个对话框。第三个对话框模板的ID设为IDD_ADD_PAGE,Caption属性改为“计算页”,添加静态文本框的Caption属性改为“最后请按下“计算”按钮”,其他属性也第一个对话框一样。
           2.创建属性页类
           按照创建对话框类和添加控件变量中的方法,在第一个对话框模板上点右键,在右键菜单中选择“Add Class”,弹出类向导对话框,在“Class name”编辑框中输入类名“CSummandPage”,与之前不同的是,因为属性页类都应继承于CPropertyPage类,所以要修改下面“Base class”的选项,在下拉列表中选择“CPropertyPage”。
           因为是第一个属性页,所以它应该有一个“下一步”按钮,在哪里添加呢?上一讲CPropertyPage类的可重载函数中提到,OnSetActive函数用于处理属性页被切换为当前活动页的消息,所以我们可以在OnSetActive函数中进行相关设置。
           那怎样重载OnSetActive函数呢?我们可以在“Class View”中找到“CSummandPage”节点,点右键弹出右键菜单,选择“Properties”,然后VS2010右侧面板上会显示对话框的属性列表,属性列表的工具栏上有个tip信息为“Overrides”的按钮,按下它,下方列表中就列出了重载函数,找到“OnSetActive”,点其右侧空白列表项出现向下箭头,再点箭头就在下面出现了“<Add>OnSetActive”的选项,选择它就会自动在CSummandPage类中添加函数OnSetActive。
     
    
           我们只需在OnSetActive函数体中添加相关代码就可以实现添加“下一步”按钮的效果了。新的函数体如下:
    C++代码
    BOOL CSummandPage::OnSetActive()   
    {   
        // TODO: Add your specialized code here and/or call the base class   
      
        // 获得父窗口,即属性表CPropertySheet类   
        CPropertySheet* psheet = (CPropertySheet*) GetParent();   
        // 设置属性表只有“下一步”按钮   
        psheet->SetWizardButtons(PSWIZB_NEXT);   
      
        return CPropertyPage::OnSetActive();   
    }  
           为第二个和第三个对话框也分别添加属性页类CAddendPage和CAddPage。但第二个对话框的属性页不需要重载OnSetActive函数。第三个对话框是最后一个对话框,所以不需要“下一步”按钮,而应该换成“完成”按钮,所以也需要重载OnSetActive函数设置“完成”按钮。重载后的OnSetActive如下:
    C++代码
    BOOL CAddPage::OnSetActive()   
    {   
        // TODO: Add your specialized code here and/or call the base class   
      
        // 获得父窗口,即属性表CPropertySheet类   
        CPropertySheet* psheet = (CPropertySheet*) GetParent();   
        //设置属性表只有“完成”按钮   
        psheet->SetFinishText(_T("完成"));   
      
        return CPropertyPage::OnSetActive();   
    }  
           上面的代码段中,字符串“完成”前加了个_T,这是因为本工程创建的时候用的默认的Unicode字符集,而如果“完成”前不加_T就是ASCII字符串。_T实际上是一个宏,工程的字符集选择为Unicode时字符串就转为Unicode字符串,选择为Muli-Byte时就转为ASCII字符串。我们可以在Solution Explorer的Addition根节点上点右键,在右键菜单上选择“Properties”,弹出工程的属性对话框,Configuration Properties->General右侧列表中的Character Set就显示选择的字符集。
           那点了第三个属性页上的“完成”按钮我们想进行某些处理的话,就重载OnWizardFinish函数,方法同OnSetActive函数。重载后的OnWizardFinish函数如下:
    C++代码
    BOOL CAddPage::OnWizardFinish()   
    {   
        // TODO: Add your specialized code here and/or call the base class   
      
        // 提示向导完成   
        MessageBox(_T("使用说明向导已阅读完!"));   
      
        return CPropertyPage::OnWizardFinish();   
    }  
            3.创建属性表类
           属性页资源和属性页类创建完以后,还不能生成向导对话框,我们还需要一个属性表类,来容纳这些属性页。
           在Solution Explorer视图中的根节点“Addition”上点右键,在右键菜单中选择Add->Class,弹出“Add Class”对话框,然后在中间区域中选择“MFC Class”,点“Add”按钮,弹出另一个类向导对话框,设置Class name为CAddSheet,Base class选择“CPropertySheet”,点“Finish”按钮,这样就属性表类就建好了。
           接下来,在新生成的AddSheet.h中包含三个属性页类的头文件:
           #include "SummandPage.h"
           #include "AddendPage.h"
           #include "AddPage.h"
           之后在AddSheet.h中添加private变量:
           CSummandPage    m_summandPage;
           CAddendPage     m_addendPage;
           CAddPage        m_addPage;
           然后在AddSheet.cpp文件中修改CAddSheet的两个构造函数为:
    C++代码
    CAddSheet::CAddSheet(UINT nIDCaption, CWnd* pParentWnd, UINT iSelectPage)   
        :CPropertySheet(nIDCaption, pParentWnd, iSelectPage)   
    {   
        // 添加三个属性页到属性表   
        AddPage(&m_summandPage);   
        AddPage(&m_addendPage);   
        AddPage(&m_addPage);   
    }   
      
    CAddSheet::CAddSheet(LPCTSTR pszCaption, CWnd* pParentWnd, UINT iSelectPage)   
        :CPropertySheet(pszCaption, pParentWnd, iSelectPage)   
    {   
        // 添加三个属性页到属性表   
        AddPage(&m_summandPage);   
        AddPage(&m_addendPage);   
        AddPage(&m_addPage);   
    }  
            4.显示向导对话框
            我们在加法计算器对话框上添加一个按钮,点击它就打开向导对话框。此按钮的ID设为IDC_INSTRUCT_BUTTON,Caption属性设为“使用说明”。
            按照为控件添加消息处理函数中所讲方法,为IDC_INSTRUCT_BUTTON按钮在CAdditionDlg类中添加点击消息的处理函数OnBnClickedInstructButton。然后在AdditionDlg.cpp文件中包含CAddSheet的头文件:#include "AddSheet.h"。最后修改OnBnClickedInstructButton函数如下:
    C++代码
    void CAdditionDlg::OnBnClickedInstructButton()   
    {   
        // TODO: Add your control notification handler code here   
      
        // 创建属性表对象   
        CAddSheet sheet(_T(""));   
        // 设置属性对话框为向导对话框   
        sheet.SetWizardMode();   
        // 打开模态向导对话框   
        sheet.DoModal();   
    }  
           到此,向导对话框就完整的创建完成了,并可以在加法计算器对话框上点“使用说明”按钮显示出来。我们来看看效果吧:
    
           上图只是被加数页的效果,点其上“下一步”按钮就可以继续显示后面的两个页面。
           是不是向导对话框没有以前想象的那般复杂了?大家可以发挥想象,进行更复杂的修改,实现更完善的功能。依然欢迎朋友们到鸡啄米博客来交流学习。
    View Code

    10.对话框:一般属性页对话框的创建及显示

    属性页对话框包括向导对话框和一般属性页对话框两类,上一节鸡啄米讲了如何创建并显示向导对话框,本节将继续介绍一般属性页对话框的创建和显示。
           实际上,一般属性页对话框的创建和显示过程和向导对话框是很类似的。鸡啄米将上一节中的向导对话框进行少量修改,使其成为一般属性页对话框。
           一般属性页对话框的创建步骤:
           1.创建属性页对话框资源
           属性页对话框资源的创建方法同向导对话框是一样的,上一讲中的对话框资源不需进行任何修改。
           2.创建属性页类
           属性页类的创建和向导对话框的属性页类也基本一样,只是一般属性页对话框中不需要“下一步”和“完成”等按钮,所以上一讲中属性页类的OnSetActive和OnWizardFinish等重载函数可以去掉。即CSummandPage类中的OnSetActive函数、CAddPage类中的OnSetActive函数和OnWizardFinish函数可以删除或注释掉。其他部分不需作任何修改。
           3.创建属性表类
           创建属性表类的过程同向导对话框属性表类也是一样的,所以上一讲中的CAddSheet类不需修改。
           4.显示一般属性页对话框
           上一讲向导对话框的显示是在OnBnClickedInstructButton函数中实现的,其中语句sheet.SetWizardMode();旨在设置属性表为向导对话框模式,所以显示一般属性页对话框时不需调用SetWizardMode成员函数。另外,我们可以将属性页对话框的标题设为“使用说明”,在构造属性表对象时将此字符串作为构造函数的参数传入。OnBnClickedInstructButton函数修改如下:
    C++代码
    void CAdditionDlg::OnBnClickedInstructButton()   
    {   
        // TODO: Add your control notification handler code here   
      
        // 创建属性表对象   
        CAddSheet sheet(_T("使用说明"));   
           
        // 打开模态一般属性页对话框   
        sheet.DoModal();   
    }  
           这样一般属性页对话框的创建和显示就讲完了,我们运行下程序,在结果对话框上点“使用说明”按钮看看效果吧:
     
    
           再总结下,一般属性页对话框和向导对话框的创建和显示的不同包括,是否需要OnSetActive和OnWizardFinish等重载函数,是否需要调用属性表类的SetWizardMode函数设置为向导对话框模式。
           是不是一般属性页对话框的创建和显示也很简单?到此,属性页对话框就讲完了。鸡啄米欢迎大家继续关注后面的内容。
    View Code

    11.对话框:一般属性页对话框的创建及显示

    属性页对话框包括向导对话框和一般属性页对话框两类,上一节鸡啄米讲了如何创建并显示向导对话框,本节将继续介绍一般属性页对话框的创建和显示。
           实际上,一般属性页对话框的创建和显示过程和向导对话框是很类似的。鸡啄米将上一节中的向导对话框进行少量修改,使其成为一般属性页对话框。
           一般属性页对话框的创建步骤:
           1.创建属性页对话框资源
           属性页对话框资源的创建方法同向导对话框是一样的,上一讲中的对话框资源不需进行任何修改。
           2.创建属性页类
           属性页类的创建和向导对话框的属性页类也基本一样,只是一般属性页对话框中不需要“下一步”和“完成”等按钮,所以上一讲中属性页类的OnSetActive和OnWizardFinish等重载函数可以去掉。即CSummandPage类中的OnSetActive函数、CAddPage类中的OnSetActive函数和OnWizardFinish函数可以删除或注释掉。其他部分不需作任何修改。
           3.创建属性表类
           创建属性表类的过程同向导对话框属性表类也是一样的,所以上一讲中的CAddSheet类不需修改。
           4.显示一般属性页对话框
           上一讲向导对话框的显示是在OnBnClickedInstructButton函数中实现的,其中语句sheet.SetWizardMode();旨在设置属性表为向导对话框模式,所以显示一般属性页对话框时不需调用SetWizardMode成员函数。另外,我们可以将属性页对话框的标题设为“使用说明”,在构造属性表对象时将此字符串作为构造函数的参数传入。OnBnClickedInstructButton函数修改如下:
    C++代码
    void CAdditionDlg::OnBnClickedInstructButton()   
    {   
        // TODO: Add your control notification handler code here   
      
        // 创建属性表对象   
        CAddSheet sheet(_T("使用说明"));   
           
        // 打开模态一般属性页对话框   
        sheet.DoModal();   
    }  
           这样一般属性页对话框的创建和显示就讲完了,我们运行下程序,在结果对话框上点“使用说明”按钮看看效果吧:
     
    
           再总结下,一般属性页对话框和向导对话框的创建和显示的不同包括,是否需要OnSetActive和OnWizardFinish等重载函数,是否需要调用属性表类的SetWizardMode函数设置为向导对话框模式。
           是不是一般属性页对话框的创建和显示也很简单?到此,属性页对话框就讲完了。鸡啄米欢迎大家继续关注后面的内容。
    View Code

    12.对话框:消息对话框

    前面几节鸡啄米讲了属性页对话框,我们可以根据所讲内容方便的建立自己的属性页对话框。本节讲解Windows系统中最常用最简单的一类对话框--消息对话框。
           我们在使用Windows系统的过程中经常会见到消息对话框,提示我们有异常发生或提出询问等。因为在软件开发中经常用到消息对话框,所以MFC提供了两个函数可以直接生成指定风格的消息对话框,而不需要我们在每次使用的时候都要去创建对话框资源和生成对话框类等。这两个函数就是CWnd类的成员函数MessageBox()和全局函数AfxMessageBox()。
           一.CWnd::MessageBox()函数和AfxMessageBox()函数的用法
           下面鸡啄米就分别讲解两个函数的用法。
           1.CWnd::MessageBox()函数
           CWnd::MessageBox()的函数原型如下:
           int MessageBox(
               LPCTSTR lpszText,
               LPCTSTR lpszCaption = NULL,
               UINT nType = MB_OK 
           );
           参数说明:
           lpszText:需要显示的消息字符串。
           lpszCaption:消息对话框的标题字符串。默认值为NULL。取值为NULL时使用默认标题。
           nType:消息对话框的风格和属性。默认为MB_OK风格,即只有“确定”按钮。
           nType的取值可以是下面两个表中任取一个值,也可以是各取一个值的任意组合。即可以指定一个对话框类型,也可以指定一个对话框图标,还可以两者都设定。
    nType 取值 参数说明
    MB_ABORTRETRY 有“终止”、“重试”和“忽略”按钮
    MB_OK 有“确定”按钮
    MB_OKCANCEL 有“确定”和“取消”按钮
    MB_RETRYCANCEL 有“重试”和“取消”按钮
    MB_YESNO 有“是”和“否”按钮
    MB_YESNOCANCEL 有“是”、“否”和“取消”按钮
    
    对话框类型表
    nType 取值 显示图标
    MB_ICONEXCLAMTIONMB_ICONWARNING 
    MB_ICONASTERISKMB_ICONINFORMATION 
    MB_ICONQUESTION 
    MB_ICONHANDMB_ICONSTOPMB_ICONERROR 
     对话框图标表
           如果想要设置nType的值为类型和图标的组合,可以像这样取值:MB_OKCANCEL | MB_ICONQUESTION。按位取或就可以了。
    
           2.AfxMessageBox()函数
           AfxMessageBox()的函数原型为:
           int AfxMessageBox(
               LPCTSTR lpszText,
               UINT nType = MB_OK,
               UINT nIDHelp = 0 
           );
           参数说明:
           lpszText:同CWnd::MessageBox()函数
           nType:CWnd::MessageBox()函数
           nIDHelp:此消息的帮助的上下文ID。默认值为0,取0时表示要使用应用程序的默认帮助上下文。
           二.CWnd::MessageBox()和AfxMessageBox()的返回值
          我们在调用了上面两个函数后,都可以弹出模态消息对话框。消息对话框关闭后,我们也都可以得到它们的返回值。两者的返回值就是用户在消息对话框上单击的按钮的ID,可以是以下值:
          IDABORT:单击“终止”按钮。
          IDCANCEL:单击“取消”按钮。
          IDIGNORE:单击“忽略”按钮。
          IDNO:单击“否”按钮。
          IDOK:单击“确定”按钮。
          IDRETRY:单击“重试”按钮。
          IDYES:单击“是”按钮。
          三.应用举例
         我们还是拿前面加法计算器的程序做例子。
           大家是否记得,在模态对话框及其弹出过程中我们修改了CAdditionDlg::OnBnClickedAddButton()函数,在点了“计算”按钮以后先弹出了一个模态对话框,询问用户是否确定要进行加法计算,并通过模态对话框DoModal函数的返回值判断用户选择了“确定”还是“取消”。这些功能很明显消息对话框完全能够实现,鸡啄米就使用消息对话框来替代原来的模态对话框。
           在非模态对话框的创建及显示中,鸡啄米注释了模态对话框的相关代码,加入了非模态对话框的创建和显示代码,我们在加入消息对话框之前将非模态对话框的代码也注释或删除掉,确保此函数中不再生成原来的模态对话框或非模态对话框。
           修改后的CAdditionDlg::OnBnClickedAddButton()函数如下:
    C++代码
    void CAdditionDlg::OnBnClickedAddButton()   
    {   
        // TODO: Add your control notification handler code here   
     
        INT_PTR nRes;   
      
        // 显示消息对话框   
        nRes = MessageBox(_T("您确定要进行加法计算吗?"), _T("加法计算器"), MB_OKCANCEL | MB_ICONQUESTION);   
        // 判断消息对话框返回值。如果为IDCANCEL就return,否则继续向下执行   
        if (IDCANCEL == nRes)   
            return;   
      
        // 将各控件中的数据保存到相应的变量   
        UpdateData(TRUE);   
      
        // 将被加数和加数的加和赋值给m_editSum   
        m_editSum = m_editSummand + m_editAddend;   
      
        // 根据各变量的值更新相应的控件。和的编辑框会显示m_editSum的值   
        UpdateData(FALSE);   
        // 设置属性对话框为向导对话框   
        //sheet.SetWizardMode();   
    }  
            编译运行,在运行结果对话框上点“计算”按钮弹出以下消息对话框:
    
           大家也可以将MessageBox函数换为AfxMessageBox()函数,同时参数进行相应修改,运行下看看效果。
           消息对话框就讲到这里了。在以后的软件开发中用到它的频率很高,希望大家慢慢熟悉并掌握它。有问题欢迎回鸡啄米博客交流或加入我们的编程入门群。
    View Code

    13.对话框:文件对话框

    上一讲鸡啄米介绍的是消息对话框,本节讲解文件对话框。文件对话框也是很常用的一类对话框。
           文件对话框的分类
          文件对话框分为打开文件对话框和保存文件对话框,相信大家在Windows系统中经常见到这两种文件对话框。例如,很多编辑软件像记事本等都有“打开”选项,选择“打开”后会弹出一个对话框,让我们选择要打开文件的路径,这个对话框就是打开文件对话框;除了“打开”选项一般还会有“另存为”选项,选择“另存为”后往往也会有一个对话框弹出,让我们选择保存路径,这就是保存文件对话框。
           正如上面举例说明的,打开文件对话框用于选择要打开的文件的路径,保存文件对话框用来选择要保存的文件的路径。
           文件对话框类CFileDialog
          MFC使用文件对话框类CFileDialog封装了对文件对话框的操作。CFileDialog类的构造函数原型如下:
    explicit CFileDialog(
       BOOL bOpenFileDialog,
       LPCTSTR lpszDefExt = NULL,
       LPCTSTR lpszFileName = NULL,
       DWORD dwFlags = OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT,
       LPCTSTR lpszFilter = NULL,
       CWnd* pParentWnd = NULL,
       DWORD dwSize = 0,
       BOOL bVistaStyle = TRUE
    );
           参数说明:
           bOpenFileDialog:指定要创建的文件对话框的类型。设为TRUE将创建打开文件对话框,否则将创建保存文件对话框。
           lpszDefExt:默认的文件扩展名。如果用户在文件名编辑框中没有输入扩展名,则由lpszDefExt指定的扩展名将被自动添加到文件名后。默认为NULL。
           lpszFileName:文件名编辑框中显示的初始文件名。如果为NULL,则不显示初始文件名。
           dwFlags:文件对话框的属性,可以是一个值也可以是多个值的组合。关于属性值的定义,可以在MSDN中查找结构体OPENFILENAME,元素Flags的说明中包含了所有属性值。默认为OFN_HIDEREADONLY和OFN_OVERWRITEPROMPT的组合,OFN_HIDEREADONLY表示隐藏文件对话框上的“Read Only”复选框,OFN_OVERWRITEPROMPT表示在保存文件对话框中如果你选择的文件存在了,就弹出一个消息对话框,要求确定是否要覆盖此文件。
           lpszFilter:文件过滤器,它是由若干字符串对组成的一个字符串序列。如果指定了文件过滤器,则文件对话框中只有符合过滤条件的文件显示在文件列表中待选择。给大家看看VS2010 MSDN中给出的一个例子:
           static TCHAR BASED_CODE szFilter[] = _T("Chart Files (*.xlc)|*.xlc|Worksheet Files (*.xls)|*.xls|Data Files (*.xlc;*.xls)|*.xlc; *.xls|All Files (*.*)|*.*||");
           这样设置过滤器以后,文件对话框的扩展名组合框中将有四个选项:Chart Files (*.xlc)、Worksheet Files (*.xls)、Data Files(*.xlc;*.xls)和All Files (*.*),大家可以看到每种文件的扩展名规定都是一个字符串对,例如Chart Files的过滤字符串是Chart Files(*.xlc)和*.xlc成对出现的。
           pParentWnd:文件对话框的父窗口的指针。
           dwSize:OPENFILENAME结构体的大小。不同的操作系统对应不同的dwSize值。MFC通过此参数决定文件对话框的适当类型(例如,创建Windows 2000文件对话框还是XP文件对话框)。默认为0,表示MFC将根据程序运行的操作系统版本来决定使用哪种文件对话框。
           bVistaStyle:指定文件对话框的风格,设为TRUE则使用Vista风格的文件对话框,否则使用旧版本的文件对话框。此参数仅在Windows Vista中编译时适用。
           文件对话框也是模态对话框,所以在打开时也需要调用CFileDialog类的DoModal()成员函数。在打开文件对话框中点了“打开”或者在保存文件对话框中点了“保存”以后,我们可以使用CFileDialog类的成员函数GetPathName()获取选择的文件路径。
           下面列出几个CFileDialog类的成员函数,我们可以使用它们获得文件对话框中的各种选择。
    GetFileExt():获得选定文件的后缀名。
    GetFileName():获得选定文件的名称,包括后缀名。
    GetFileTitle():获得选定文件的标题,即不包括后缀名。
    GetFolderPath():获得选定文件的目录。
    GetNextPathName():获得下一个选定的文件的路径全名。
    GetPathName():获得选定文件的路径全名。
    GetReadOnlyPref():获得是否“以只读方式打开”。
    GetStartPosition():获得文件名列表中的第一个元素的位置。
           文件对话框实例
          根据前面所讲内容,鸡啄米给大家做个文件对话框实例。
           1.创建一个基于对话框的MFC应用程序工程,名称设为“Example17”。
           2.修改主对话框IDD_EXAMPLE17_DIALOG的模板,删除自动生成的“TODO: Place dialog controls here.”静态文本框,添加两个编辑框,ID分别为IDC_OPEN_EDIT和IDC_SAVE_EDIT,再添加两个按钮,ID分别设为IDC_OPEN_BUTTON和IDC_SAVE_BUTTON,Caption分别设为“打开”和“保存”。按钮IDC_OPEN_BUTTON用于显示打开文件对话框,编辑框IDC_OPEN_EDIT显示在打开文件对话框中选择的文件路径。按钮IDC_SAVE_BUTTON用于显示保存文件对话框,编辑框IDC_SAVE_BUTTON显示在保存文件对话框中选择的文件路径。
           3.分别为按钮IDC_OPEN_BUTTON和IDC_SAVE_BUTTON添加点击消息的消息处理函数CExample17Dlg::OnBnClickedOpenButton()和CExample17Dlg::OnBnClickedSaveButton()。
           4.修改两个消息处理函数如下:
    C++代码
    void CExample17Dlg::OnBnClickedOpenButton()   
    {   
        // TODO: Add your control notification handler code here   
        // 设置过滤器   
        TCHAR szFilter[] = _T("文本文件(*.txt)|*.txt|所有文件(*.*)|*.*||");   
        // 构造打开文件对话框   
        CFileDialog fileDlg(TRUE, _T("txt"), NULL, 0, szFilter, this);   
        CString strFilePath;   
      
        // 显示打开文件对话框   
        if (IDOK == fileDlg.DoModal())   
        {   
            // 如果点击了文件对话框上的“打开”按钮,则将选择的文件路径显示到编辑框里   
            strFilePath = fileDlg.GetPathName();   
            SetDlgItemText(IDC_OPEN_EDIT, strFilePath);   
        }   
    }   
      
      
    void CExample17Dlg::OnBnClickedSaveButton()   
    {   
        // TODO: Add your control notification handler code here   
        // 设置过滤器   
        TCHAR szFilter[] = _T("文本文件(*.txt)|*.txt|Word文件(*.doc)|*.doc|所有文件(*.*)|*.*||");   
        // 构造保存文件对话框   
        CFileDialog fileDlg(FALSE, _T("doc"), _T("my"), OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT, szFilter, this);   
        CString strFilePath;   
      
        // 显示保存文件对话框   
        if (IDOK == fileDlg.DoModal())   
        {   
            // 如果点击了文件对话框上的“保存”按钮,则将选择的文件路径显示到编辑框里   
            strFilePath = fileDlg.GetPathName();   
            SetDlgItemText(IDC_SAVE_EDIT, strFilePath);   
        }   
    }  
           上面显示编辑框内容时,鸡啄米使用了Windows API函数SetDlgItemText,当然也可以先给编辑框关联变量,然后再使用鸡啄米在创建对话框类和添加控件变量中介绍的
    CDialogEx::UpdateData()函数,但是鸡啄米比较习惯使用SetDlgItemText函数,感觉比较灵活。
           5.运行此程序,在结果对话框上点“打开”按钮,显示打开文件对话框如下:
    
           点“保存”按钮后,显示保存文件对话框:
    
           在打开文件对话框和保存文件对话框都选择了文件路径后,主对话框如下:
    
           到此,文件对话框就讲完了,是不是依然很简单?如果忘记了文件对话框类构造函数的参数意义,可以回到鸡啄米来看看或者在MSDN上查阅。
    View Code

    14.对话框:字体对话框

    鸡啄米在上一节为大家讲解了文件对话框的使用,本节则主要介绍字体对话框如何应用。
           字体对话框的作用是用来选择字体。我们也经常能够见到。MFC使用CFontDialog类封装了字体对话框的所有操作。字体对话框也是一种模态对话框。
           CFontDialog类的构造函数
           我们先来了解CFontDialog类。它的常用构造函数原型如下:
    CFontDialog(
       LPLOGFONT lplfInitial = NULL,
       DWORD dwFlags = CF_EFFECTS | CF_SCREENFONTS,
       CDC* pdcPrinter = NULL,
       CWnd* pParentWnd = NULL 
    );
           参数说明:
           lplfInitial:指向LOGFONT结构体数据的指针,可以通过它设置字体的一些特征。
           dwFlags:指定选择字体的一个或多个属性,详情可在MSDN中查阅。
           pdcPrinter:指向一个打印设备上下文的指针。
           pParentWnd:指向字体对话框父窗口的指针。
           上面的构造函数中第一个参数为LOGFONT指针,LOGFONT结构体中包含了字体的大部分特征,包括字体高度、宽度、方向、名称等等。下面是此结构体的定义:
    typedef struct tagLOGFONT {
        LONG lfHeight;
        LONG lfWidth;
        LONG lfEscapement;
        LONG lfOrientation;
        LONG lfWeight;
        BYTE lfItalic;
        BYTE lfUnderline;
        BYTE lfStrikeOut;
        BYTE lfCharSet;
        BYTE lfOutPrecision;
        BYTE lfClipPrecision;
        BYTE lfQuality;
        BYTE lfPitchAndFamily;
        TCHAR lfFaceName[LF_FACESIZE];
    } LOGFONT;
           获取字体对话框中所选字体
           我们在字体对话框中选择了字体后,如何获取选定的字体呢?我们可以通过CFontDialog类的成员变量m_cf间接获得选定字体的CFont对象。m_cf是CHOOSEFONT类型的变量,CHOOSEFONT结构体定义如下:
    typedef struct {
        DWORD lStructSize;
        HWND hwndOwner;
        HDC hDC;
        LPLOGFONT lpLogFont;
        INT iPointSize;
        DWORD Flags;
        COLORREF rgbColors;
        LPARAM lCustData;
        LPCFHOOKPROC lpfnHook;
        LPCTSTR lpTemplateName;
        HINSTANCE hInstance;
        LPTSTR lpszStyle;
        WORD nFontType;
        INT nSizeMin;
        INT nSizeMax;
    } CHOOSEFONT, *LPCHOOSEFONT;
           CHOOSEFON结构体中有个成员lpLogFont,它是指向LOGFONT结构体变量的指针,就像上面所说,LOGFONT中包含了字体特征,例如,我们可以通过LOGFONT的lfFaceName得知字体名。
           我们最终要获得的是所选择字体的CFont对象,有了字体的LOGFONT怎样获得对应的CFont对象呢?使用CFont类的成员函数CreateFontIndirect可以达到此目的。函数原型如下:
           BOOL CreateFontIndirect(const LOGFONT* lpLogFont );
           参数是LOGFONT指针类型,我们可以传入CFontDialog类成员变量m_cf的lpLogFont成员,就可以得到所选字体的CFont对象了。
           字体对话框应用实例
           鸡啄米给大家做一个字体对话框的实例。先介绍此实例要实现的功能,生成一个对话框,对话框中放置一个“字体选择”按钮和一个编辑框。点击“字体选择”按钮将弹出字体对话框。编辑框用于显示所选字体名,并以选定的字体来显示字体名字符串,例如,如果选择了宋体,则在编辑框中以宋体显示字符串“宋体”。
           以下是创建此实例的步骤:
           1.创建一个基于对话框的MFC工程,名字为“Example18”。
           2.在自动生成的主对话框IDD_EXAMPLE18_DIALOG的模板中,删除“TODO: Place dialog controls here.”静态文本框,添加一个按钮,ID设为IDC_FONT_BUTTON,Caption设为“字体选择”,用于显示字体对话框来选择字体,再添加一个编辑框,ID设为IDC_FONT_EDIT,用来以所选字体显示字体名字符串。
           3.在Example18Dlg.h中为CExample18Dlg类添加private成员变量:CFont m_font;,用来保存编辑框中选择的字体。
           4.为按钮IDC_FONT_BUTTON添加点击消息的消息处理函数CExample18Dlg::OnBnClickedFontButton()。
           5.修改消息处理函数CExample18Dlg::OnBnClickedFontButton()如下:
    C++代码
    void CExample18Dlg::OnBnClickedFontButton()   
    {   
        // TODO: Add your control notification handler code here   
        CString strFontName;    // 字体名称   
        LOGFONT lf;             // LOGFONT变量   
      
        // 将lf所有字节清零   
        memset(&lf, 0, sizeof(LOGFONT));   
      
        // 将lf中的元素字体名设为“宋体”   
        _tcscpy_s(lf.lfFaceName, LF_FACESIZE, _T("宋体"));   
           
        // 构造字体对话框,初始选择字体名为“宋体”   
        CFontDialog fontDlg(&lf);   
      
        if (IDOK == fontDlg.DoModal())     // 显示字体对话框   
        {   
            // 如果m_font已经关联了一个字体资源对象,则释放它   
            if (m_font.m_hObject)   
            {   
                m_font.DeleteObject();   
            }   
            // 使用选定字体的LOGFONT创建新的字体   
            m_font.CreateFontIndirect(fontDlg.m_cf.lpLogFont);   
            // 获取编辑框IDC_FONT_EDIT的CWnd指针,并设置其字体   
            GetDlgItem(IDC_FONT_EDIT)->SetFont(&m_font);   
      
            // 如果用户选择了字体对话框的OK按钮,则获取被选择字体的名称并显示到编辑框里   
            strFontName = fontDlg.m_cf.lpLogFont->lfFaceName;   
            SetDlgItemText(IDC_FONT_EDIT, strFontName);   
        }   
    }  
           6.最后,编译运行程序。显示结果对话框,点击“字体选择”按钮,将弹出字体对话框,默认选择为“宋体”,我们改而选择“华文彩云”字体点“确定”,编辑框中会像如下显示:
    
           到此,我们又学会了字体对话框的使用,对于以后在界面开发中控制显示的字体很有帮助。有问题欢迎在鸡啄米留言。
    View Code

    15.对话框:颜色对话框

     鸡啄米在上一节中为大家讲解了字体对话框的使用方法,熟悉了字体对话框,本节继续讲另一种通用对话框--颜色对话框。
           颜色对话框大家肯定也不陌生,我们可以打开它选择需要的颜色,简单说,它的作用就是用来选择颜色。MFC中提供了CColorDialog类封装了颜色对话框的所有操作,我们可以通过它显示颜色对话框,并获取颜色对话框中选择的颜色。颜色对话框跟字体对话框一样,也是一种模态对话框。
           CColorDialog类的构造函数
    CColorDialog(
       COLORREF clrInit = 0,
       DWORD dwFlags = 0,
       CWnd* pParentWnd = NULL 
    );
           参数说明:
           clrInit:默认选择颜色的颜色值,类型为COLORREF,实际上就是unsigned long类型。如果没有设置它的值,则默认为RGB(0,0,0),即黑色。
           注:RGB(r,g,b)是宏,可以计算颜色值。括号中的三个值分别为红、绿、蓝分量的值。
           dwFlags:自定义颜色对话框功能和外观的属性值。详情可在MSDN中查阅。
           pParentWnd:颜色对话框的父窗口的指针。
           获取颜色对话框中所选颜色值
           我们使用颜色对话框的最终目的还是要获得在颜色对话框中选择的颜色值。为此CColorDialog类的成员函数GetColor()能够很好的实现我们的要求。GetColor()函数的原型为:
           COLORREF GetColor( ) const;
           它返回所选颜色的COLORREF值。
           如果我们想获得R、G、B各分量的值呢?可以根据GetColor得到的COLORREF颜色值,通过使用GetRValue、GetGValue和GetBValue三个宏获得。GetRValue的语法形式为:
           BYTE GetRValue(DWORD rgb);
           参数rgb就是COLORREF颜色值,返回值即是R分量值。其他两个宏的形式与之类似。例如,GetColor()函数返回的COLORREF为10000,则R分量值就是GetRValue(10000)。
           颜色对话框应用实例
           鸡啄米下面给大家做一个颜色对话框的小例子。此例要实现的功能简单介绍下:生成一个对话框,对话框中放置一个“颜色选择”按钮,四个静态文本框和四个编辑框。四个静态文本框分别显示Color:、R:、G:、B:,每个静态文本框后面跟一个编辑框,分别用来显示颜色对话框中选择的颜色值和所选颜色值的红色分量、绿色分量、蓝色分量。
           以下是实例创建的步骤:
           1.创建一个基于对话框的MFC工程,名字为“Example19”。
           2.在自动生成的主对话框IDD_EXAMPLE19_DIALOG的模板中,删除“TODO: Place dialog controls here.”静态文本框,添加一个按钮,ID设为IDC_COLOR_BUTTON,Caption设为“颜色选择”,用于显示颜色对话框来选择颜色。再添加四个静态文本框,ID分别为IDC_COLOR_STATIC、IDC_R_STATIC、IDC_G_STATIC、IDC_B_STATIC,Caption分别设为“Color:”、“R:”、“G:”、“B:”,然后每个静态文本框后添加一个编辑框,四个编辑框的ID分别为IDC_COLOR_EDIT、IDC_R_EDIT、IDC_G_EDIT、IDC_B_EDIT,分别用来显示颜色对话框中选择的颜色值和所选颜色值的红色分量、绿色分量、蓝色分量。
           3.为按钮IDC_COLOR_BUTTON添加点击消息的消息处理函数CExample19Dlg::OnBnClickedColorButton()。
           4.修改消息处理函数CExample19Dlg::OnBnClickedColorButton()如下:
    C++代码
    void CExample19Dlg::OnBnClickedColorButton()   
    {   
        // TODO: Add your control notification handler code here   
        COLORREF color = RGB(255, 0, 0);      // 颜色对话框的初始颜色为红色  
        CColorDialog colorDlg(color);         // 构造颜色对话框,传入初始颜色值   
      
        if (IDOK == colorDlg.DoModal())       // 显示颜色对话框,并判断是否点击了“确定”   
        {   
            color = colorDlg.GetColor();      // 获取颜色对话框中选择的颜色值   
            SetDlgItemInt(IDC_COLOR_EDIT, color);         // 在Color编辑框中显示所选颜色值   
            SetDlgItemInt(IDC_R_EDIT, GetRValue(color));  // 在R编辑框中显示所选颜色的R分量值   
            SetDlgItemInt(IDC_G_EDIT, GetGValue(color));  // 在G编辑框中显示所选颜色的G分量值   
            SetDlgItemInt(IDC_B_EDIT, GetBValue(color));  // 在B编辑框中显示所选颜色的B分量值   
        }   
    }  
           5.最后编译运行程序,在结果对话框中点击“颜色选择”按钮,弹出颜色对话框。初始状态下,选择框在红色上,我们选另一种颜色,此时的颜色对话框如下:
    
            点“确定”,主对话框上的四个编辑框中分别显示了选择的颜色值、R分量、G分量和B分量:
    
           我们在实际开发中,可以用获取到的颜色值来设置其他对象的颜色,使用还是很方便的。
           关于颜色对话框就讲到这里了。其实各种对话框的使用都有很多相似之处,相信大家越来越熟悉了。最后还是欢迎大家继续关注鸡啄米的VS2010/MFC入门教程。
    View Code

    更多 http://www.jizhuomi.com/software/162.html

    转载于:https://www.cnblogs.com/blogpro/p/11456980.html

    展开全文
  • 零基础情况下,想学一门语言,学习Python更合适,相比较其他不少主流编程语言,有更好的可读性,上手更容易,那么如何快速掌握python?设定目标:做 Python 开发除了熟悉语言本身之外,还需要掌握很多相关联的技能,...
  • 强烈推荐Python。其实这个问题在入门阶段一直是争议十分大的问题,n多语言,n多推荐,到最后搞到新手一会听说这种语言适合...要解决这个问题,首先要明白一个根本问题,怎样挑选适合入门编程语言?我推荐从难度这...
  • 鸡啄米在这套VS2010/MFC编程入门教程中将会给大家讲解怎样使用VS2010进行可视化编程,也就是基于窗口的程序。  C++编程入门系列主要偏重于理论方面的知识,目的是让大家打好底子,练好内功,在使用VC++编程时不至于...
  • 强烈推荐Python。其实这个问题在入门阶段一直是争议十分大的问题,n多语言,n多推荐,到最后搞到新手一会听说这种语言适合...要解决这个问题,首先要明白一个根本问题,怎样挑选适合入门编程语言?我推荐从难度这...
  • 很多刚刚进大学初学编程的同学很多都会有这个疑惑,虽然已经有很多文章已经提到了这个问题,但是今天我还是给大家一个答案,希望对那些想要学习编程的同学有所帮助。常用的编程语言有几种?目前主流的编程语言主要有...
  • 游戏编程入门手册

    千次阅读 2008-12-21 20:09:00
    游戏编程入门手册 原文地址: http://www.gameres.com/Tutor/ 游戏制作新人: 用什么语言和编译器来做游戏? DirectX是什么? 学编程需要哪些书? 我怎样制作游戏? 哪些书是...
  • 这是一篇Python入门指南,针对那些没有任何编程经验️,从零开始学习Python的同学。.不管你学习的出发点是兴趣驱动????、拓展思维,还是工作需要????、想要转行,都可以此文作为一个参考。.在这个信息爆炸的时代,以...
  • 如果你以一个初学者的身份选择了这条路,那你该选择什么编程语言作为入门学习语言? 你可能想成为一个APP开发工程师;你可能想成为一个Web前端开发工程师或者后端开发工程师;你也可能想成为AI(人工智能)工程师...
  • Linux/Unix编程怎样入门

    千次阅读 2007-04-23 10:05:00
    1,先有linux环境搭minGW和cygwin都有点麻烦,最最简单的办法还是装个...入门阶段熟悉gcc命令行,最基本的参数,如,-g,-W,-O,-o,-c 建议看man gcc(很大找想要的)4.编译第一个helloworld程序: 基本命令 gcc helloworl
  • 知乎上高分回答编程入门指南 v1.5可以给各位提供一个参考,对编程的启蒙,入门的学习过程都有一定帮助。根据回答中的建议,python作为一种启蒙语言而存在,现将几本Python基础书籍推荐给各位。Python语言及其应用(美...
  • 一:第二章小结:1.如何使用变量2.如何创建描述性变量名以及如何消除名称错误和语法错误;3.字符串是什么,以及如何使用小写、大写和首字母大写的方式显示字符串;4.使用空白来显示整洁的输出,以及如何剔除字符串中...
  • Shell编程入门

    2013-05-07 11:36:11
    或许﹐许多人都已经听过shell 或bash 这些名字﹐但不知道您是否知道它们究竟是什么东东呢﹖ 先回到电脑基础常识上吧﹕所有的...请问﹕如果没有键盘和荧幕您是怎样使用电脑的﹖ 但是﹐您透过键盘进行的输入﹐以及
  • 以下书籍都是现在业内主流编程入门好书,同步收录在顶书,通过下面网址进入,实时读书: 顶书-提升IT技术和认知​i-book.top 程序是怎样跑起来的 本书从计算机的内部结构开始讲起,以图配文的形式详细讲解了二...
  • 怎样才能快速入门Java?对于想要加入IT行业的人来说,Java是一个不错的选择,不仅人才需求大,就业薪资也非常不错。许多人都非常看好Java发展前景,接下来千锋小编就给大家介绍一下。  Java学习难不难?  从...
  • 前面的文章我们介绍了西门子SCL编程的变量和表达式,今天这篇文章,我们来介绍下SCL的语句与结构。语句在计算机科学中被称为"Satement"。它是一条能被执行的代码,其作用是向计算机/PLC系统发出操作指令,要求执行...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 994
精华内容 397
关键字:

怎样编程入门