pdf to epub c# : Convert word pdf bookmarks application SDK cloud html wpf winforms class doxygen1-part1705

1.4 CompilingfromsourceonWindows
8
Manuallyadding-BdynamicafterthetargetruleinMakefile.doxygenandMakefile.doxytag
willfixthis:
$(TARGET): $(OBJECTS) $(OBJMOC)
$(LINK) $(LFLAGS) -o $(TARGET) $(OBJECTS) $(OBJMOC) $(LIBS) -Bdynamic
GCC compiler problems
Older versions of the GNU compiler have problems with constant strings containing characters with char-
acter codes larger than 127. Therefore the compiler will fail to compile some of the translator
xx.h files.
Aworkaround, if you are planning to use the English translation only, is to configure doxygen with the
--english-only option.
On some platforms (such as OpenBSD) using some versions of gcc with -O2 can lead to eating all memory
during the compilation of files such as config.cpp. As a workaround use –debug as a configure option or
omit the -O2 for the particular files in the Makefile.
Gcc versions before 2.95 may produce broken binaries due to bugs in these compilers.
Dot problems
Due to a change in the way image maps are generated, older versions of doxygen (<=1.2.17) will not work
correctly with newer versions of graphviz (>=1.8.8). The effect of this incompatibility is that generated
graphs in HTML are not properly clickable. For doxygen 1.3 it is recommended to use at least graphviz
1.8.10 or higher. For doxygen 1.4.7 or higher it is recommended to use GraphViz 2.8 or higher to avoid
font issues.
Red Hat 9.0 problems
If you get the following error after running make
tmake error: qtools.pro:70: Syntax error
then first type
export LANG=
before running make.
1.4 Compiling from source on Windows
From version 1.5.0 onwards, build files are provided for Visual Studio 2005. Also the free (as in beer)
”Express” version of Developer Studio can be used to compile doxygen. Alternatively, you can compile
doxygentheUnixway usingCygwin orMinGW.
Before you can compile doxygen you need to download and install the C++ compiler of Visual Studio.
Since Microsoft apparently wants to lure everyone into using their .NET stuff, they made things somewhat
difficult when you use the Express version. You need todo some manual steps in order to setup a
proper working environment for building native win32 applications such as Doxygen.
The next step is to install unxutils (seehttp://sourceforge.net/projects/unxutils). This
packages contains the tools flex and bison which are needed during the compilation process if you use
aCVS snapshot of doxygen (the official source releases come with pre-generated sources). Download the
zip extract it to e.g. c:\tools\unxutils.
Now
you
need
to
add/adjust the
following
environment variables
(via
Control
Panel/System/Advanced/Environment Variables):
User Manual forDoxygen1.5.3,written by Dimitri vanHeesch
c
1997-2006
Convert word pdf bookmarks - add, remove, update PDF bookmarks in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Empower Your C# Project with Rapid PDF Internal Navigation Via Bookmark and Outline
pdf reader with bookmarks; bookmarks in pdf from word
Convert word pdf bookmarks - VB.NET PDF bookmark library: add, remove, update PDF bookmarks in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Empower Your VB.NET Project with Rapid PDF Internal Navigation Via Bookmark and Outline
how to bookmark a pdf file in acrobat; create bookmark in pdf automatically
1.5 Installing the binaries on Windows
9
• add c:\tools\unxutils\usr\local\wbin; to the start of PATH
• set BISON
SIMPLE to c:\tools\unxutils\usr\share\bison.simple
Download doxygen’s source tarball and put it somewhere (e.g use c:\tools)
Now start a new command shell and type
cd c:\tools
gunzip doxygen-x.y.z.src.tar.gz
tar xvf doxygen-x.y.z.src.tar
to unpack the sources.
Now your environment is setup to build doxygen and doxytag.
Insidethe doxygen-x.y.z directory you will find a winbuild directory containing a Doxygen.sln
file. Open this file in Visual Studio. You can now build the Release or Debug flavor of Doxygen and
Doxytag by right-clicking the project in the solutions explorer, and selecting Build.
Note
that
compiling
Doxywizard
currently
requires
Qt
version
3
(see
http://www.trolltech.com/products/qt/qt3).
If you
do
not have
a
commercial license, you can build Doxywizard with the open source version (see
http://qtwin.sourceforge.net/qt3-win32/compile-msvc-2005.php),butIhavenot
tried this myself.
Also read the next section for additional tools you may need to install to run doxygen with certain features
enabled.
1.5 Installing the binaries on Windows
Doxygen comes as a self-installing archive, so installation is extremely simple. Just follow the dialogs.
After installation it is recommended to also download and install GraphViz (version 2.8 or better is highly
recommended). Doxygen can use the dot tool of the GraphViz package to render nicer diagrams, see the
HAVE
DOToptionintheconfigurationfile.
If you want to produce compressed HTML files (seeGENERATE
HTMLHELP)intheconfigfile,then
you need the Microsoft HTML help workshop. You can download it fromMicrosoft.
In order to generate PDF output or use scientific formulas you will also need to installLaTeX and
Ghostscript.
For LaTeX a number of distributions exists. Popular onces that should work with doxygen areMikTex
andXemTex.
Ghostscript can bedownloaded from Sourceforge.
After installing LaTeX and Ghostscript you’ll need to make sure the tools latex.exe, pdflatex.exe, and
gswin32c.exe are present in the search path of a command box. Followthese instructions if you are
unsure and run the commands from a command box to verify it works.
1.6 Tools used to develop doxygen
Doxygen was developed and tested under Linux & MacOSX using the following open-source tools:
• GCC version 3.3.6 (Linux) and 4.0.1 (MacOSX)
• GNU flex version 2.5.33 (Linux) and 2.5.4 (MacOSX)
User Manual forDoxygen1.5.3,written by Dimitri vanHeesch
c
1997-2006
VB.NET PDF File Compress Library: Compress reduce PDF size in vb.
Bookmarks. Comments, forms and multimedia. Convert smooth lines to curves. VB.NET Demo Code to Optimize An Exist PDF File in Visual C#.NET Project.
how to create bookmark in pdf automatically; delete bookmarks pdf
C# PDF File Split Library: Split, seperate PDF into multiple files
Split PDF file by top level bookmarks. The following C# codes explain how to split a PDF file into multiple ones by PDF bookmarks or outlines.
excel hyperlink to pdf bookmark; export bookmarks from pdf to excel
10
• GNU bison version 1.75
• GNU make version 3.80
• Perl version 5.8.1
• VIM version 6.2
• Firefox 1.5
• Troll Tech’s tmake version 1.3 (included in the distribution)
• teTeX version 2.0.2
• CVS 1.12.12
2 Getting started
The executable doxygen is the main program that parses the sources and generates the documentation.
See sectionDoxygenusagefor more detailed usage information.
The executable doxytag is only needed if you want to generate references to external documentation
(i.e. documentation that was generated by doxygen) for which you do not have the sources. See section
Doxytag usageformoredetailedusageinformation.
Optionally, the executable doxywizard can be used, which is agraphicalfront-end for editing the con-
figuration file that is used by doxygen and for running doxygen in a graphical environment. For Mac OS X
doxywizard will be started by clicking on the Doxygen application icon.
The following figure shows the relation between the tools and the flow of information between them (it
looks complex but that’s only because it tries to be complete):
User Manual forDoxygen1.5.3,written by Dimitri vanHeesch
c
1997-2006
VB.NET PDF File Split Library: Split, seperate PDF into multiple
Demo Code in VB.NET. The following VB.NET codes explain how to split a PDF file into multiple ones by PDF bookmarks or outlines.
bookmark pdf documents; create bookmarks pdf files
C# PDF File Compress Library: Compress reduce PDF size in C#.net
Bookmarks. Comments, forms and multimedia. Hidden layer content. Convert smooth lines to curves. Flatten visible layers. C#.NET DLLs: Compress PDF Document.
create bookmarks pdf file; create bookmark pdf
2.1 Step 1: Creating a configuration file
11
Config file
Doxyfile
− headers
− images
− footers
generate/update
read
read
read
Tag file(s)
Doxywizard
generate
read
generate/edit
XML files
Latex files
Makefile
+
Doxygen
Your application
doxmlparser lib
make pdf
make ps
latex
custom
output
postscript
PDF
refman.rtf
MS−Word
doc
import
HTML
pages
HTML Help Workshop
chm
Man pages
parse
Doxytag
read
Windows only
read
Sources
Custom
generate
Figure 1: Doxygen information flow
2.1 Step 1: Creating a configuration file
Doxygen uses a configuration file to determine all of its settings. Each project should get its own configura-
tion file. A project can consist of a singlesource file, but can also bean entire source tree that is recursively
scanned.
To simplify the creation of a configuration file, doxygen can create a template configuration file for you.
To do this call doxygen from the command line with the -g option:
doxygen -g <config-file>
where <config-file> is the name of the configuration file. If you omit the file name, a file named
Doxyfile will be created. If a file with the name <config-file> already exists, doxygen will rename
it to <config-file>.bak before generating the configuration template. If you use - (i.e. the minus sign) as
the file name then doxygen will try to read the configuration file from standard input (stdin), which can
be useful for scripting.
The configuration file has a format that is similar to that of a (simple) Makefile. It consists of a number of
assignments (tags) of the form:
TAGNAME = VALUE or
User Manual forDoxygen1.5.3,written by Dimitri vanHeesch
c
1997-2006
C# PDF Convert to HTML SDK: Convert PDF to html files in C#.net
it extremely easy for C# developers to convert and transform document file, converted by C#.NET PDF to HTML all the original anchors, links, bookmarks and font
bookmarks pdf; how to create bookmarks in pdf file
XDoc.Word for .NET, Advanced .NET Word Processing Features
Create Word from PDF; Create Word from OpenOffice (.odt); More about Word SDK Word Export. Convert Word to PDF; Convert Word to HTML5; Convert Word to Tiff; Convert
pdf bookmarks; bookmark pdf acrobat
2.2 Step 2: Running doxygen
12
TAGNAME = VALUE1 VALUE2 ...
You can probably leave the values of most tags in a generated template configuration file to their default
value. See sectionConfigurationfor more details about the configuration file.
If you do not wish to edit the config file with a text editor, you should have a look atdoxywizard, which is a
GUI front-end that can create, read and write doxygen configuration files, and allows setting configuration
options by entering them via dialogs.
For a small project consisting of a few C and/or C++ source and header files, you can leaveINPUT tag
empty and doxygen will search for sources in the current directory.
If you have a larger project consisting of a source directory or tree you should assign the root directory or
directories to theINPUT tag, and add one or more file patterns to theFILE
PATTERNStag(forinstance
∗.cpp ∗.h). Only files that match one of the patterns will be parsed (if the patterns are omitted a list
of source extensions is used). For recursive parsing of a source tree you must set theRECURSIVE tag to
YES. To further fine-tune the list of files that is parsed theEXCLUDE andEXCLUDE
PATTERNStags
can be used. To omit all test directories from a source tree for instance, one could use:
EXCLUDE_PATTERNS =
*
/test/
*
Doxygen looks at the file’s extension to determine how to parse a file. If a file has an .idl or .odl
extension it is treated as an IDL file. If it has a .java extension it is treated as a file written in Java. Files
ending with .cs are treated as C# files and the .py extension selects the Python parser. Finally, files with
the extensions .php, .php4, .inc or .phtml are treated as PHP sources. Any other extension is parsed
as if it is a C/C++ file, where files that end with .m are treated as Objective-C source files.
If you start using doxygen for an existing project (thus without any documentation that doxygen is aware
of), you can still get an idea of what the structure is and how the documented result would look like. To
do so, you must set theEXTRACT
ALLtagintheconfigurationfiletoYES.Then,doxygenwillpretend
everything in your sourcesis documented. Please notethat asa consequencewarnings about undocumented
members will not be generated as long asEXTRACT
ALLissettoYES.
To analysean existing piece of softwareit is useful to cross-referencea (documented) entity with its defini-
tion in the source files. Doxygen will generate such cross-references if you set theSOURCE
BROWSER
tag to YES. It can also include the sources directly into the documentation by settingINLINE
SOURCES
to YES (this can be handy for code reviews for instance).
2.2 Step 2: Running doxygen
To generate the documentation you can now enter:
doxygen <config-file>
Depending on your settings doxygen will create html, rtf, latex, xml and/or man directories inside
the output directory. As the names suggest these directories contain thegenerated documentation in HTML,
RTF, LAT
E
X, XML and Unix-Man page format.
The default output directory is the directory in which doxygen is started. The root directory to which
the output is written can be changed using theOUTPUT
DIRECTORY. Theformatspecificdirectory
within theoutput directory can be selected using theHTML
OUTPUT, RTF
OUTPUT,LATEX
OUTPUT,
XML
OUTPUT,and MAN
OUTPUTtagsoftheconfigurationfile.Iftheoutputdirectorydoesnotexist,
doxygen will try to create it for you (but it will not try to create a whole path recursively, like mkdir
-p does).
User Manual forDoxygen1.5.3,written by Dimitri vanHeesch
c
1997-2006
C# Word - Convert Word to HTML in C#.NET
VB.NET How-to, VB.NET PDF, VB.NET Word, VB toolkit SDK, preserves all the original anchors, links, bookmarks and font C#: Convert Word document to HTML5 files.
bookmark a pdf file; bookmarks pdf documents
.NET PDF SDK - Description of All PDF Processing Control Feastures
Full page navigation, zooming & rotation; Outlines, bookmarks, & thumbnail display; PDF Export. Convert PDF to Word (.docx); Convert PDF to HTML; Convert PDF to
add bookmarks to pdf online; adding bookmarks in pdf
2.2 Step 2: Running doxygen
13
2.2.1 HTML output
The generated HTML documentation can be viewed by pointing a HTML browser to the index.html
file in the html directory. For the best results a browser that supports cascading style sheets (CSS) should
be used (I’m using Mozilla, Safari, Konqueror, and sometimes IE6 to test the generated output).
Some of thefeatures the HTML section (such asGENERATE
TREEVIEW)requireabrowserthatsupports
DHTML and Javascript.
If you plan to use the search engine (seeSEARCHENGINE), you should view the HTML output via a
PHP-enabled web server (e.g. apache with the PHP module installed).
2.2.2 LaTeX output
The generated LAT
E
Xdocumentation must first becompiled by a LAT
E
Xcompiler (I use a recent teTeX distri-
bution). To simplify theprocess of compiling the generated documentation, doxygen writes aMakefile
into the latex directory.
The contents and targets in the Makefile depend on the setting ofUSE
PDFLATEX.Ifitisdisabled(set
to NO), then typing make in the latex directory a dvi file called refman.dvi will be generated. This
file can then be viewed using xdvi or converted into a PostScript file refman.ps by typing make ps
(this requires dvips).
To put 2 pages on one physical page use make ps
2on1 instead. Theresulting PostScript file can be send
to a PostScript printer. If you do not have a PostScript printer, you can try to use ghostscript to convert
PostScript into something your printer understands.
Conversion to PDF is also possible if you have installed the ghostscript interpreter; just type make pdf
(or make pdf
2on1).
To get the best results for PDF output you should set thePDF
HYPERLINKSand USE
PDFLATEXtags
to YES. In this case the Makefile will only contain a target to build refman.pdf directly.
2.2.3 RTF output
Doxygen combines the RTF output to a single file called refman.rtf. This file is optimized for importing
into the Microsoft Word. Certain information is encoded using field. To show the actual value you need
to select all (Edit - select all) and then toggle fields (right click and select the option from the drop down
menu).
2.2.4 XML output
The XML output consists of a structured ”dump” of the information gathered by doxygen. Each compound
(class/namespace/file/...) has its own XML file and there is also an index file called index.xml.
Afile called combine.xslt XSLT script is also generated and can be used to combine all XML files into a
single file.
Doxygen also generates two XML schema files index.xsd (for the index file) and compound.xsd (for the
compound files). This schema file describes the possible elements, their attributes and how they are struc-
tured, i.e. it the describes the grammar of the XML files and can be used for validation or to steer XSLT
scripts.
In the addon/doxmlparser directory you can find a parser library for reading the XML output produced by
doxygen in an incremental way (see addon/doxmlparser/include/doxmlintf.h for theinterfaceof thelibrary)
User Manual forDoxygen1.5.3,written by Dimitri vanHeesch
c
1997-2006
2.3 Step 3: Documenting the sources
14
2.2.5 Man page output
The generated man pages can be viewed using the man program. You do need to make sure the man
directory is in the man path (see the MANPATH environment variable). Note that there are some limitations
to the capabilities of the man page format, so some information (like class diagrams, cross references and
formulas) will be lost.
2.3 Step 3: Documenting the sources
Although documenting the sources is presented as step 3, in a new project this should of course be step 1.
Here I assume you already have some code and you want doxygen to generate a nice document describing
the API and maybe the internals as well.
If theEXTRACT
ALLoptionissettoNOintheconfigurationfile(thedefault),thendoxygenwillonly
generate documentation for documented members, files, classes and namespaces. So how do you document
these? For members, classes and namespaces there are basically two options:
1. Place a special documentation block in front of the declaration or definition of the member, class
or namespace. For file, class and namespace members it is also allowed to place the documention
directly after the member. See sectionSpecialdocumentationblocks to learn more about special
documentation blocks.
2. Place a special documentation block somewhere else (another file or another location) and put a
structural command in the documentation block. A structural command links a documentation block
to a certain entity that can be documented (e.g. a member, class, namespace or file). See section
Documentation at other placestolearnmoreaboutstructuralcommands.
Files can only be documented using the second option, since there is no way to put a documentation
block before a file. Of course, file members (functions, variable, typedefs, defines) do not need an explicit
structural command; just putting a special documentation block in front or behind them will do.
The text inside a special documentation block is parsed before it is written to the HTML and/or L
A
T
E
X
output files.
During parsing the following steps take place:
• The special commands inside the documentation are executed. See sectionSpecialCommands for
an overview of all commands.
• If a line starts with some whitespace followed by one or more asterisks (∗) and then optionally more
whitespace, then all whitespace and asterisks are removed.
• All resulting blank lines are treated as a paragraph separators. This saves you from placing new-
paragraph commands yourself in order to make the generated documentation readable.
• Links are created for words corresponding to documented classes (unless the word is preceded by a
%; then the word will not be linked and the % sign is removed).
• Links to members are created when certain patterns are found in the text. See sectionAutomaticlink
generationformoreinformationonhowtheautomaticlinkgenerationworks.
• HTML tags that are in the documentation are interpreted and converted to L
A
T
E
Xequivalents for the
L
A
T
E
Xoutput. See sectionHTMLCommandsfor an overview of all supported HTML tags.
User Manual forDoxygen1.5.3,written by Dimitri vanHeesch
c
1997-2006
15
3 Documenting the code
3.1 Special documentation blocks
Aspecial documentation block is a C or C++ style comment block with some additional markings, so
doxygen knows it is a piece of documentation that needs to end up in the generated documentation. For
Python codethere is adifferent comment convention, which can be found in sectionSpecialdocumentation
blocks in Python
For each code item there are two (or in some cases three) types of descriptions, which together form the
documentation: a brief description and detailed description, both are optional. For methods and func-
tions there is also a third type of description, the so called ”in body” description, which consists of the
concatenation of all comment blocks found within the body of the method or function.
Having more than one brief or detailed description is allowed (but not recommended, as the order in which
the descriptions will appear is not specified).
As the name suggest, a brief description is a short one-liner, whereas the detailed description provides
longer, more detailed documentation. An ”in body” description can also act as a detailed description or
can describe a collection of implementation details. For the HTML output brief descriptions are also use
to provide tooltips at places where an item is referenced.
There are several ways to mark a comment block as a detailed description:
1. You can use the JavaDoc style, which consist of a C-style comment block starting with two ∗’s, like
this:
/
**
*
... text ...
*
/
2. or you can use the Qt style and add an exclamation mark (!) after the opening of a C-style comment
block, as shown in this example:
/
*
!
*
... text ...
*
/
In both cases the intermediate ∗’s are optional, so
/
*
!
... text ...
*
/
is also valid.
3. A third alternative is to use a block of at least two C++ comment lines, where each line starts with
an additional slash or an exclamation mark. Here are examples of the two cases:
///
/// ... text ...
///
or
//!
//!... text ...
//!
User Manual forDoxygen1.5.3,written by Dimitri vanHeesch
c
1997-2006
3.1 Special documentation blocks
16
4. Some people like to make their comment blocks more visible in the documentation. For this purpose
you can use the following:
/
************************************************
*
... text
***********************************************
/
or
/////////////////////////////////////////////////
/// ... text ...
/////////////////////////////////////////////////
For the brief description there are also several posibilities:
1. One could use the\briefcommand with one of the above comment blocks. This command ends at
the end of a paragraph, so the detailed description follows after an empty line.
Here is an example:
/
*
! \brief Brief description.
*
Brief description continued.
*
*
Detailed description starts here.
*
/
2. IfJAVADOC
AUTOBRIEFissettoYESintheconfigurationfile,thenusingJavaDocstylecomment
blocks will automatically start a brief description which ends at the first dot followed by a space or
new line. Here is an example:
/
**
Brief description which ends at this dot. Details follow
*
here.
*
/
The option has the same effect for multi-line special C++ comments:
/// Brief description which ends at this dot. Details follow
/// here.
3. A third option is to use a special C++ style comment which does not span more than one line. Here
are two examples:
/// Brief description.
/
**
Detailed description.
*
/
or
//! Brief descripion.
//! Detailed description
//! starts here.
Note the blank line in the last example, which is required to separate the brief description from the
block containing the detailed description. TheJAVADOC
AUTOBRIEFshouldalsobesettoNOfor
this case.
As you can see doxygen is quite flexible. The following however is not legal
User Manual forDoxygen1.5.3,written by Dimitri vanHeesch
c
1997-2006
3.1 Special documentation blocks
17
//! Brief description, which is
//! really a detailed description since it spans multiple lines.
/
*
! Oops, another detailed description!
*
/
because doxygen only allows one brief and one detailed description.
Furthermore, if there is one brief description before a declaration and onebefore a definition of a code item,
only the one before the declaration will be used. If the same situation occurs for a detailed description, the
one before the definition is preferred and the one before the declaration will be ignored.
Here is an example of a documented piece of C++ code using the Qt style:
//!
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.
User Manual forDoxygen1.5.3,written by Dimitri vanHeesch
c
1997-2006
Documents you may be interested
Documents you may be interested