这个例程将告诉你如何把 newton 物理引擎和你的图形引擎结合起来。

如果你没有解过 SDK 包，先解开包。

打开 Visual studio 找到包里的 Tutorials.dsw 后双击。

选择子项目 Tutorial 1 getting started 并使它活动起来。

选择 Tutorial.cpp 文件并双击在编辑框中打开。

在文件的开始你将发现 include 部分。

看下面几行（注意黑体）：

找到文件主要函数。

首先初始化图形引擎。在这个案例中我们已经把 opengl 的初始化压成一个简单的函数。它可以完成你的引擎中主要系统的初始化。

接下来你将看到场景初始化的的相关调用。

最后是 opengl 的主体循环调用，它描述的是你的引擎主循环。

现在找到函数 InitScene ， 物理引擎的初始化就在那里。

在这个例程中，我们将实现一个简单的物理场景：一个刚体球悬浮在真空中。

我们将看到：

// 译者注：实际上这之前还需要声明 nWorld ，以下许多地方类似

它将为 nowton 世界创建一个句柄，并初始化所有内部结构。这里我们先忽视两个参数，在下个例程中我们将对之详细说明。我们保持这个指向 nowton 世界的句柄为全程变量。

但是它（ nowton 世界）不可能脱离 opengl 循环，所以我们要设定一个事件去终止 nowton 世界和我们已经分配的所有资源。这就是 onexit (Cleanup) 所要做的。

接下来我们要创建一个刚体，在这之前我们要创建它的几何碰撞。（刚体每时每刻都必须有几何碰撞）

所以我们根据图形箱子大小去创建一个碰撞。

第一个参数是 Newton world ，接下来的是箱子大小，最后一个参数是用来设置从源刚体而得到的几何碰撞中偏转转换矩阵。当使用 Null 时，这个箱子会被源物体替代。现在我们创建刚体并保存为一个全局变量。

当你使用完碰撞对象后你要释放它，碰撞对象在 newton 里是唯一一个使用 reference 数的对象，这是有必要的因为其他刚体可以分享几何碰撞。取个例子来说，你可以创建很多个同样大小的箱子，你可以使用同一个几何碰撞。

当 newton 创建一个刚体，质量设置为无限以保持这个刚体呈静态。我们需要去告诉 newton 这个物体是动态的，就调用下面这个

别去考虑质量与惯性，他们将会在例程 the Dealing with Mass and Inertia 中讨论。

我们同样需要在这个世界中物体的位置。

这里没有应力和应变应用在这个物体上，我们仅仅是应用了最初的角速度 。

// 这里的 NewtonBodySetOmega 中的 Omega 其实是小写希腊字母最后一个—— ω ，即物理中的角速度。

这是所有初始化，现在是主要的仿真循环。

每一帧在 OPENGL 或者你的引擎中都将在主要仿真循环中创建一个回调。在这个例程中，它是函数 DrawScene 。

注意我们需要取得从最后一次更新到现在的时间。它使用下面这个函数。

接下来，我们调用 NewtonUpdate 来用时间量推动这个世界。

现在我们需要找到在世界更新的过程中位置改变的物体变换矩阵，在这个例子中我们只有一个物体。

现在我们需要去应用这些转换到图形物体中。

最后我们渲染场景。

这些都包含在主循环中。

最后的事情就是终止应用程序，我们用点击关闭窗体按钮或者按 ESCAPE 键来终止。每个案例都是用 exit(0) 。

这个函数将会调用所有终止程序并次序颠倒的运行。在我们的案例中我们仅仅是使用 cleanup 函数去销毁 the Newton world 。

操作这个例程用 WSAD 键。

改变运动趋势按鼠标并移动鼠标。

从这个例程中我们可以看出，物理引擎的基本操作步骤。

1、   初始化物理引擎。

2、   取得物体的几何碰撞。

3、   根据几何碰撞创建刚体。

4、   释放几何碰撞（很多人会忘记，但很重要）

5、   设置变换矩阵。

6、   更新物理引擎。

7、   取得变换矩阵。

8、   根据取得的变换矩阵设置绘制物体当前状态。

9、   释放物理引擎。

Linux内核源码是很具吸引力的，特别是当你弄懂了一个分析了好久都没搞懂的问题；或者是被你修改过了的内核，顺利通过编译，一切运行正常的时候。那种成就感真是油然而生！而且，对内核的分析，除了出自对技术的狂热追求之外，这种令人生畏的劳动所带来的回报也是非常令人着迷的，这也正是它拥有众多追随者的主要原因：

首先，你可以从中学到很多的计算机的底层知识，如后面将讲到的系统的引导和硬件提供的中断机制等；其它，象虚拟存储的实现机制，多任务机制，系统保护机制等等，这些都是非都源码不能体会的。

同时，你还将从操作系统的整体结构中，体会整体设计在软件设计中的份量和作用，以及一些宏观设计的方法和技巧：Linux的内核为上层应用提供一个与具体硬件不相关的平台；同时在内核内部，它又把代码分为与体系结构和硬件相关的部分，和可移植的部分；再例如，Linux虽然不是微内核的，但他把大部分的设备驱动处理成相对独立的内核模块，这样减小了内核运行的开销，增强了内核代码的模块独立性。

而且你还能从对内核源码的分析中，体会到它在解决某个具体细节问题时，方法的巧妙：如后面将分析到了的Linux通过Botoom_half机制来加快系统对中断的处理。

最重要的是：在源码的分析过程中，你将会被一点一点地、潜移默化地专业化。一个专业的程序员，总是把代码的清晰性，兼容性，可移植性放在很重要的位置。他们总是通过定义大量的宏，来增强代码的清晰度和可读性，而又不增加编译后的代码长度和代码的运行效率；他们总是在编码的同时，就考虑到了以后的代码维护和升级。 甚至，只要分析百分之一的代码后，你就会深刻地体会到，什么样的代码才是一个专业的程序员写的，什么样的代码是一个业余爱好者写的。而这一点是任何没有真正分析过标准代码的人都无法体会到的。

然而，由于内核代码的冗长，和内核体系结构的庞杂，所以分析内核也是一个很艰难，很需要毅力的事；在缺乏指导和交流的情况下，尤其如此。只有方法正确，才能事半功倍。正是基于这种考虑，作者希望通过此文能给大家一些借鉴和启迪。

由于本人所进行的分析都是基于2.2.5版本的内核；所以，如果没有特别说明，以下分析都是基于i386单处理器的2.2.5版本的Linux内核。所有源文件均是相对于目录/usr/src/linux的。

方法之一：从何入手

要分析Linux内核源码，首先必须找到各个模块的位置，也即要弄懂源码的文件组织形式。虽然对于有经验的高手而言，这个不是很难；但对于很多初级的Linux爱好者，和那些对源码分析很有兴趣但接触不多的人来说，这还是很有必要的。

1、Linux核心源程序通常都安装在/usr/src/linux下，而且它有一个非常简单的编号约定：任何偶数的核心（的二个数为偶数，例如2.0.30）都是一个稳定地发行的核心，而任何奇数的核心（例如2.1.42）都是一个开发中的核心。

2、核心源程序的文件按树形结构进行组织，在源程序树的最上层，即目录/usr/src/linux下有这样一些目录和文件：

● COPYING: GPL版权申明。对具有GPL版权的源代码改动而形成的程序，或使用GPL工具产生的程序，具有使用GPL发表的义务，如公开源代码。

● CREDITS: 光荣榜。对Linux做出过很大贡献的一些人的信息。

● MAINTAINERS: 维护人员列表，对当前版本的内核各部分都有谁负责。

● Makefile: 第一个Makefile文件。用来组织内核的各模块，记录了个模块间的相互这间的联系和依托关系，编译时使用。仔细阅读各子目录下的Makefile文件对弄清各个文件这间的联系和依托关系很有帮助。

● ReadMe: 核心及其编译配置方法简单介绍。

● Rules.make: 各种Makefilemake所使用的一些共同规则。

● REPORTING-BUGS:有关报告Bug 的一些内容。

● Arch/ ：arch子目录包括了所有和体系结构相关的核心代码。它的每一个子目录都代表一种支持的体系结构，例如i386就是关于intel cpu及与之相兼容体系结构的子目录。PC机一般都基于此目录。

● Include/: include子目录包括编译核心所需要的大部分头文件。与平台无关的头文件在 include/linux子目录下，与 intel cpu相关的头文件在include/asm-i386子目录下,而include/scsi目录则是有关scsi设备的头文件目录。

● Init/： 这个目录包含核心的初始化代码(注：不是系统的引导代码)，包含两个文件main.c和Version.c，这是研究核心如何工作的好的起点之一。

● Mm/：这个目录包括所有独立于 cpu 体系结构的内存管理代码，如页式存储管理内存的分配和释放等。而和体系结构相关的内存管理代码则位于arch/*/mm/，例如arch/i386/mm/Fault.c。

● Kernel/：主要的核心代码，此目录下的文件实现了大多数linux系统的内核函数，其中最重要的文件当属sched.c。同样，和体系结构相关的代码在arch/*/kernel中。

● Drivers/： 放置系统所有的设备驱动程序。每种驱动程序又各占用一个子目录：如，/block 下为块设备驱动程序，比如ide（ide.c）。如果你希望查看所有可能包含文件系统的设备是如何初始化的，你可以看drivers/block/genhd.c中的device_setup()。它不仅初始化硬盘，也初始化网络，因为安装nfs文件系统的时候需要网络。

● Documentation/: 文档目录,没有内核代码，只是一套有用的文档，可惜都是English的，看看应该有用的哦。

● Fs/: 所有的文件系统代码和各种类型的文件操作代码，它的每一个子目录支持一个文件系统, 例如fat和ext2。

● Ipc/: 这个目录包含核心的进程间通讯的代码。

● Lib/: 放置核心的库代码。

● Net/: 核心与网络相关的代码。

● Modules/: 模块文件目录，是个空目录，用于存放编译时产生的模块目标文件。

● Scripts/: 描述文件，脚本，用于对核心的配置。

一般，在每个子目录下，都有一个 Makefile 和一个Readme 文件，仔细阅读这两个文件，对内核源码的理解很有用。

对Linux内核源码的分析，有几个很好的入口点：一个就是系统的引导和初始化，即从机器加电到系统核心的运行；另外一个就是系统调用，系统调用是用户程序或操作调用核心所提供的功能的接口。对于那些对硬件比较熟悉的爱好者，从系统的引导入手进行分析，可能来的容易一些；而从系统调用下口，则可能更合适于那些在dos或Uinx、Linux下有过C编程经验的高手。这两点，在后面还将介绍到。

方法之二：以程序流程为线索，一线串珠

从表面上看，Linux的源码就象一团扎乱无章的乱麻，其实它是一个组织得有条有理的蛛网。要把整个结构分析清楚，除了找出线头，还得理顺各个部分之间的关系，有条不紊的一点一点的分析。

所谓以程序流程为线索、一线串珠，就是指根据程序的执行流程，把程序执行过程所涉及到的代码分析清楚。这种方法最典型的应用有两个：一是系统的初始化过程；二是应用程序的执行流程：从程序的装载，到运行，一直到程序的退出。

为了简便起见，遵从循序渐进的原理，现就系统的初始化过程来具体的介绍这种方法。系统的初始化流程包括：系统引导，实模式下的初始化，保护模式下的初始化共三个部分。下面将一一介绍。

Linux系统的常见引导方式有两种：Lilo引导和Loadin引导；同时linux内核也自带了一个bootsect-loader。由于它只能实现linux的引导，不像前两个那样具有很大的灵活性（lilo可实现多重引导、loadin可在dos下引导linux）,所以在普通应用场合实际上很少使用bootsect-loader。当然，bootsect-loader也具有它自己的优点：短小没有多余的代码、附带在内核源码中、是内核源码的有机组成部分，等等。

bootsect-loader在内和源码中对应的程序是 /Arch/i386/boot/bootsect.S 。下面将主要是针对此文件进行的分析。

几个相关文件：

　　
　　<1> /Arch/i386/boot/bootsect.S 
　　
　　<2> /include/linux/config.h 
　　
　　<3> /include/asm/boot.h 
　　
　　<4> /include/linux/autoconf.h/PRE>

控制台下的截图

1.在控制台(Console)下如果只想要获得文字的输出，例如命令的帮助信息，可以直接使用管道命令，将输出内容保存到指定的文件当中。

2.可以用setterm程序来获得控制台下的屏幕截图。命令格式为：setterm -dump 1

上面命令中，1指第一个虚拟控制台，如要获得第二个虚拟控制台的内容，应改为2，依此类推。关于setterm的具体用法可以参考它的man信息。

3.使用控制台下的屏幕截图软件snapscreenshot，下载地址为 http://bisqwit.iki.fi/source/snapscreenshot.html。使用这个软件可以获取控制台屏幕，并输出一个tga格式的图像文件。如果想获得其它格式的图像文件，可以用图像转换程序(如convert)将它转换成其它格式的文件。截图效果请见图1。

snapscreenshot的安装与卸载：

◆安装 先将下载的软件包解开，然后进入这个目录，执行以下命令即可：

#./configure； #make install/PRE>

/CENTER>

◆卸载

#make uninstall

◆使用方法

如果想获得帮助使用下面命令：

#snapscreenshot --help

截取图像可以使用如下命令：

#snapscreenshot >snap.tga

上面代码表示按默认方式截取图片。

#snapscreenshot -c6 -x3 >snap.tga

上面这个命令表明自己指定参数来获得图片。

#./examplerun

上面这个命令表示用本软件自带的脚本来获得图片。

如果想直接得到自己想要的图像格式，可以结合管道命令来使用，例如： #snapscreenshot|tgatopnm|pnmtojpeg>myscreen.jpeg

关于snapscreenshot的详细情况请参阅帮助信息及readme文件。

X-Window环境下截图

1.用X-Window中的截图工具 xwd与xwud是X-Window中自带的截图工具。xwd是一个非常传统的屏幕截图软件，它可以截取程序窗口和全屏图像。xwud是X11图形工具客户程序，可以用它来显示由xwd程序创建的图形文件。这两个程序包含在X-Window的标准发布版中。截取图像的方法如下: #xwd > myscreen.xwd 查看图像使用如下命令： #xwud -in myscreen.xwd 实际使用中，可以用xwd结合其它图形转换程序直接获得想要的输出文件。例如： xwd -frame|xwdtopnm|pnmtojpeg>myscreen.jpeg 如果直接写成script,则使用更加方便。例如我的脚本myscreen的文件内容为： #/bin/bash sleep 5 xwd -screen -root|xwdtopnm|pnmtopng> myscreen.png

2.用GNOME中的软件截图

在GNOME 1.4中的选单里，有小程序→公用程序→ScreenShooter。这个程序非常好用,可以对整个桌面和单个窗口和桌面区域进行截图，图片默认保存在你登录的目录下。例如用root登录，图片就保存在/root下,保存格式为jpg。但是，在Red Hat 8.0的GNOME选单中这个程序消失了，不过可以直接运行gnome-panel-screenshot进行截图。

3.用KDE中的软件来截图

图2 Ksnapshot软件的界面

在KDE中包含了一个很好用的截图软件Ksnapshot。这个软件的使用比较直观，其界面如图2。只要在“Delay”框里填上延迟时间，在“Filename”栏里填上要保存的文件名和路径，然后用鼠标点“Grab”按钮就可以进行抓图了。

点击“Grab”按钮后，Ksnapshot软件的窗口自动最小化到任务栏，同时鼠标变成“十”字状。这时移动鼠标到其它运行着的程序窗口点一下，就会抓取这个程序的窗口图像；如果是在桌面空白的地方点击，则会抓取到整个屏幕的图像。抓完图后，Ksnapshot的窗口又会弹出来，这时点击“保存（Save）”就将抓取的图像保存到指定位置。

4.使用快捷键

在Red Hat 8.0的默认配置下，“Alt+PrintScreen”为窗口截图，“PrintScreen”为桌面截图。

使用其它软件截图

1.ImageMagick

ImageMagick是一个通过命令行执行的图像处理程序软件包，提供了一个完整的抓图、显示、简单编辑处理的解决方案。其中display可以显示图片和进行简单的图像编辑处理，如缩放、转换质量、绘图、简单虑镜等；convert用来转换图像格式；import可以用来屏幕抓图。当使用import程序进行抓图时，可以将图片直接保存成想要的格式。

抓图方法如下：

#import -window root myscreen.jpeg

上述命令表示捕捉全屏。

#import mywindows.jpeg

上面这个命令是捕捉窗口，这时光标会变成“十”状，在某个窗口按下去这个窗口内容就被存入文件。详细情况请看man信息。

2.GIMP

ImageMagick这个软件包对于一般的图像处理来说已经足够了，如果你还需要一个功能更加强大的软件，那就用GIMP。GIMP也是一个自由软件，它几乎可以和Photoshop相媲美，被认为是Linux下的Photoshop。

要用GIMP截取屏幕图像，可做如下操作：文件（File）→获取（ Acquire）→ Screen Shot…… 。然后在弹出来的窗口中选择“single window”，就可以抓取程序窗口图像；选择“whole windows”抓取全屏图像。图3为使用GIMP抓的图。

用GIMP截取出来的图像存什么格式都可以，并且可以马上进行处理，获得自己满意的效果。

作为一个内核编程者，有那么几个软件是你必须要有的，看作是你进行内核编程的几件法宝吧，下面我一一列举出来：

1、gcc

大名鼎鼎的gcc我想没有人不知道的吧？它是任何编程者必然要先安装的一个武器了。不过一般如果你是安装的Debian系统，应该已经默认安装了的。要是Ubuntu你就安装一下吧，安装方法嘛，就是输入：

apt-get install gcc/PRE>

apt-get install make/PRE>

apt-cache search kernel-source
uname -r/PRE>

HOSTCC  scripts/basic/fixdep
scripts/basic/fixdep.c:105:23: error: sys/types.h: 没有那个文件或目录/PRE>

apt-cache search kernel-headers
uname -r
apt-get instakk kernel-headers-xxxx/PRE>

apt-cache search kernel-kbuild
uname -r
apt-get install kernel-kbuild-xxxx/PRE>

apt-get install build-essential/PRE>

apt-get install kernel-package/PRE>

apt-get instakk initrd-tools/PRE>

/* hello.c */
#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
static int hello_init(void)
{
    printk(KERN_ALERT "Hello, linux kernel module\n");
    return 0;
}
static void hello_exit(void)
{
    printk
(KERN_ALERT "Goodbye, I've created a linux kernel module sucessfully\n");
}
module_init(hello_init);
module_exit(hello_exit);
MODULE_LICENSE("GPL");/PRE>

#Makefile for hello.c file
#
KERNEL_DIR:=/usr/src/linux
obj-m:=hello.o
default: 
 $(MAKE) -C $(KERNEL_DIR) SUBDIRS=$(PWD) modules
clean: 
 $(RM) .*.cmd *.mod.c *.o *.ko -r .tmp/PRE>

insmode hello.ko/PRE>

rmmod hello/PRE>

下载Doxygen相关文件

　　Doxygen 是一个类似 JavaDoc 的文档生成工具。有了它，C++爱好者就可以为自己的源代码很方便地生成美观实用的文档了。

为代码生成文档标注基础

　　您可以使用JavaDoc风格，类似于由C风格的注释块：

/**
* ... 文本 ...
*/

此外您也可以使用Qt风格，如

/*!
* ... 文本...
*/

以上两种风格中间的*是可选的，也就是下面这样写也是可以的：

/*!
... 文本...
*/

第三种是使用至少两行C++"//"注释，如：

///
/// ... 文本...
///

或者

//!
//!...文本...
//!

有的程序员也许喜欢下面这种风格，有比较好的视觉效果：

/////////////////////////////////////////////////
/// ... 文本...
/////////////////////////////////////////////////

　　对于简单的描述信息，可能有几种情况。一种是在注释块的开头使用\brief命令，该命令一直到段落结束有效，所以详细描述信息从空一行后开始，如下例：

/*! \brief 简洁的描述信息 description.
* 又一些简洁的描述信息。
*
* 详细描述信息从这里开始。
*/

　　在配置文件中，如果JAVADOC_AUTOBRIEF设为YES，则Doxygen将使用JavaDoc风格的注释块，从简洁描述信息后的点空格. 开始为详细描述信息，例如：

/** 简洁信息结尾是一个点号. 详细描述信息从
* 这里开始
*/

该选项对C++风格的多行注释也是有效的：

///简洁信息结尾是一个点号. 详细描述信息从
///这里开始

或者：

/// 简洁描述信息
/** 详细描述信息*/

或者：

//!简洁描述信息

//!详细描述信息从
//!这里开始

　　此例中间空行用来分割简洁描述信息块和详细描述信息块。可见doxygen的文档标注使用格式是非常自由的。不过要注意下面格式是不合法的，因为doxygen只允许一块详细描述信息对应一块简洁描述信息：

//!简洁描述信息
//! 详细描述信息
/*! 注意，又一详细描述信息!
*/

下例使用Qt风格的文档标注：
//! A test class. 
/*!
A more elaborate class description.
*/

class Test
{
  public:

    //! An enum.
    /*! More detailed enum description. */
    enum TEnum { 
                 TVal1, /*!< Enum value TVal1. */  
                 TVal2, /*!< Enum value TVal2. */  
                 TVal3  /*!< Enum value TVal3. */  
               } 
         //! Enum pointer.
         /*! Details. */
         *enumPtr, 
         //! Enum variable.
         /*! Details. */
         enumVar;  
    
    //! A constructor.
    /*!
      A more elaborate description of the constructor.
    */
    Test();

    //! A destructor.
    /*!
      A more elaborate description of the destructor.
    */
   ~Test();
    
    //! A normal member taking two arguments and returning an integer value.
    /*!
      \param a an integer argument.
      \param s a constant character pointer.
      \return The test results
      \sa Test(), ~Test(), testMeToo() and publicVar()
    */
    int testMe(int a,const char *s);
       
    //! A pure virtual member.
    /*!
      \sa testMe()
      \param c1 the first argument.
      \param c2 the second argument.
    */
    virtual void testMeToo(char c1,char c2) = 0;
   
    //! A public variable.
    /*!
      Details.
    */
    int publicVar;
       
    //! A function variable.
    /*!
      Details.
    */
    int (*handler)(int a,int b);
};

　　Doxygen的文档标注是不是非常容易？当然还可以有更高级的应用，如标注列表、分组，甚至支持生成公式(Latex)。上面只编译了最简单的一些使用方法，更多内容请参考Doxygen的帮助文档doxygen_manual。

附带文档的说明：

　　DoxygWizard是基于QT的简易图形用户界面，简化了Doxygen的使用。您可以在DoxygWizard里对需要生成的文档进行设置，可保存为"Doxyfile"，然后调用Doxygen生成文档。需要注意的是，文件路径不支持中文，所以尽可能使您的源代码和文档目录均为英文名。在"Doxyfile"文件同一目录请放置一个"mylogo"纯文本文件，内容可以是一些版权标识信息，这些信息将显示在生成文档页面的最下边，如果没有此"mylogo"文件，将生成默认的版权标识信息。
　　样式表文件Orignl_doxygen.css、green_doxygen.css、yellow_doxygen.css、Blue_doxygen.css，改文件名为doxygen.css后，拷贝到生成html文档的目录内可以改变文档显示的样式。
　　OUT PUT_LANGUAGE 可选项为Englisth(英文文档), Chinese(中文文档), En_Can_Cn(支持中文注释的英文文档)

相关网址：

http://www.doxygen.org/download.html
您还需要下载graphviz dot画图：
http://www.research.att.com/sw/tools/graphviz/

• Download Installer - 1847 Kb
• Download source - 47 Kb

Introduction

As good as Visual Studio .NET is, I still miss some features in it. But MS knew that they couldn't fulfill every wish so they provided a way to write addins. That's what I've done. Sure, most of the functions in my Tools could also be done with macros, but I wanted them all packed together with an installer.

Tools

• Run Doxygen
• Insert Doxygen comments
• Build Solution stats
• Dependency Graph
• Inheritance Graph
• Swap .h<->.cpp
• Colorize
• } End of
• #region/#endregion for c++
• Search the web

Run Doxygen

This command first pops up a dialog box in which you can configure the output Doxygen should produce. For those who don't know Doxygen: it's a free tool to generate source documentations. It can produce documentation in different formats like html and even windows help format! See http://www.doxygen.org/ for details. Since the dialog box doesn't offer all possible settings for doxygen, you can always edit the file Doxyfile.cfg manually which is created the first time you run it. All settings in that file override the settings you enter in the dialog box.

If you set Doxygen to generate html output, the resulting index.html is opened inside the IDE. A winhelp output (index.chm) will be opened outside the IDE.

The command available from the Tools menu builds the documentation for the whole solution. If you don't want that for example if you have several third party projects in your solution then you can build the documentation also for single projects. To do that the KingsTools add a command to the right click menu in the solution explorer.

If you want to update Doxygen to a newer version (as soon as one is released) simply overwrite the doxygen.exe in the installation directory. The same applies to the dot.exe.

TODO: find a way to integrate the generated windows help file into VS help.

Insert Doxygen comments

Doxygen needs comments that follow certain conventions to build documentation from. This part of the tools inserts them for you. Either from the right click menu in the code editor window or from the submenu under Tools->Kings Tools. Just place the caret over a method or class header. The inserted comment for a method or function would look like this:

				/**
 *
 * \param one
 * \param two
 * \param three
 * \return
 */
BOOL myfunction(int one, int two, int three);

You now have to simply insert a description in the second comment line and descriptions for each parameter of the function/method. And of course a description of the return value.

You can customize the function comments by editing the files "functionheadertop.txt", "functionparams.txt" and "functionheaderbottom.txt". Please read the comments inside those files on how to do that. If you don't want to change the function comments for all your projects then you can place any of those files into your project directory (that way it will be used for your project) or inside the folder of your source files (that way it will be used only for the files inside that specific folder).

The inserted comment for a class looks like this:

				/**
 * \ingroup projectname
 *
 * \par requirements
 * win98 or later, win2k or later, win95 with IE4 or later, winNT4 with IE4 
 * or later
 *
 * \author user
 *
 * \par license
 * This code is absolutely free to use and modify. The code is provided 
 * "as is" with no expressed or implied warranty. The author accepts no 
 * liability if it causes any damage to your computer, causes your pet to 
 * fall ill, increases baldness or makes your car start emitting strange 
 * noises when you start it up. This code has no bugs, just undocumented 
 * features!
 *
 * \version 1.0
 * \date 06-2002
 * \todo
 * \bug
 * \warning
 *
 */
				class CRegBase

The '\ingroup projectname' means that the class is inside the project 'projectname'. That statement helps Doxygen to group classes together. Insert the description of the class right after that statement. If you want to include pictures to illustrate the class, use '\image html "picture.jpg"'. For more helpful tags you can use please check out the Doxygen website. The '\par requirements' section you have to modify yourself to fit the truth of your class. It's not necessary for Doxygen, but I found it very useful to give that information inside a class documentation. The name after the '\author' tag is the currently logged in user. Maybe you want to change that too to include an email address.

You can customize the class comments by editing the file "classheader.txt" Please read the comments inside that file on how to do that. If you don't want to change the class comments for all your projects then you can place that files into your project directory (that way it will be used for your project) or inside the folder of your source files (that way it will be used only for the files inside that specific folder).

The last few tags should be self-explanatory. Under the line '\version' I usually insert short descriptions of what changed between versions.

Build Solution stats

This is a simple line counter. It counts all the lines of all files in your solution, grouped by projects. The generated html file with the counted lines (code, comments, empty) is then opened in the IDE. Since I haven't found a way to add a file directly to a solution and not to a project the file is just opened for view in the IDE.

Dependency and Inheritance graph

These two commands build graphs of the class relations in your solution. See my previous article about this. The difference to my old tool is that it now generates graphs for all projects in the solution and puts all the graphs in one single html page.

Swap .h<->.cpp

This is something a simple macro could also do: it swaps between header and code files. For better accessibility it also is on the right click menu of the code editor. Really nothing special but it can be useful sometimes.

Colorize

This tool goes through all files of the current solution and looks for class, function and macronames. It then writes them to a usertype.dat file, makes the IDE to read that file and deletes it again. After you run this tool, all class, function and macronames of your solution appear colored in the code editor. Default color is the same color as normal keywords, but you can change that under Tools->Options, in the Options dialog select Environment->Fonts and Colors.

If you don't want the colors anymore, just run the command 'disable coloring' and everything will be in normal colors again. I didn't want to overwrite some possible usertype.dat file already created by some user so the tool simply creates a temporary usertype.dat file instead. If you want to have the colors again the next time the IDE starts, you either have to rerun the command (doesn't take very long to execute) or change the code of the tool yourself.

} End of

Have you ever wrote a bunch of code which looked like this:

Ok, I admit this isn't a very good style of programming, but sometimes it can't be avoided. And in those cases the code is horrible to read because you don't know which closing brace belongs to which opening statement without scrolling or using the macro 'Edit.GotoBrace' several times. This tool provides a function which inserts comments after the closing brace automatically. The code snippet above would look like this:

Comments are only inserted for closing braces of if, while, for and switch statements.

If you don't want to insert comments automatically while editing, you can turn off this function. If you just don't want those comments at specific places you have to move the caret either upwards (instead of downwards which happens if you press enter) or click with the mouse so that the caret doesn't go to the line below the closing brace. Comments are also not inserted when the opening brace is less than two lines above.

#region/#endregion for C++

VS.NET introduced to possibility to outline portions of text in the code editor. That's a very useful feature wthat helps navigating through big bunches of code. But the outlined sections are not saved between sessions. VB and C# provide keywords to outline sections. In VB its '#Region' and '#End Region', in C# its '#region' and '#endregion'. Only for C++ MS didn't provide such keywords (at least I haven't found them yet). With this tool you can now enable that feature for C++ too. To prevent compiler errors for those who have not installed this tool I used '//#region' and '//#endregion' as the keywords. With the comment lines before the compiler won't complain. Use those keywords like this:

Whenever you open a document with such keywords the tool will automatically create outlining sections. The section are also created when you type the '//#endregion' keyword and a matching '//#region' is found. As you can see, you can easily nest the sections. The code above would then look like this:

This function can't be deactivated. If you don't want it, simply don't use those keywords :)

Search the web

These two small addons perform a simple web site search either in the google groups or on CP. Select a piece of text in the code editor, right click to pop up the menu and then select where to search for the selected text. That's all. The search results will be opened inside VS.NET.

Install

To install the tools, just double-click the *.msi file and follow the instructions. If the tools are not automatically activated the next time you start the IDE, then please activate them under Tools->Add-In Manager. Make sure you select both the addin and the box 'startup'.

All additional files needed for the tools are also packed in the installer, including Doxygen and the dot files. So you don't have to grab them separately from the web.

Source

Full source code is provided with these tools. The addin is written in VB.NET cause first there was just one simple tool that I wanted immediately - and VB is good enough for that. Then the tool grew and I added more functions. So the code is surely not the best example for good programming (no plan, no structure -> chaos). But maybe it might still be of interest for those