|
|
|
 Help files generated
with dHelp have look and
feel of the standard Delphi's help files:
- Topics generated with dHelp can contain links to the VCL help
as if it is your own help project, so users of your help will not find
any difference. See the picture.
- By default topics generated with dHelp will look the same
(colors, fonts, pages organization, etc.) as topics of the standard
Delphi 5 help files. See the picture.
- dHelp can automatically install/uninstall help file that you
generated into the desired Delphi/C++ Builder version.
- After you installed help file generated with dHelp, it's
automatically integrated to the Delphi's indexes and contents, and
when you press F1 and Ctrl+F1 it will show your topics and indexes
together with Delphi standard topics and indexes. See the picture.
dHelp
"understands" these formats
when importing the information required to build help file:
- PAS/DPR/INC. dHelp will parse your PAS, DPR and INC
files and will automatically build help files for the source code
items (classes, interfaces, types, procedures, variables, events,
properties, methods, etc.) found in these files.
- INT. If you don't have source of the unit, you can specify
INT file (interface part) and dHelp will use it instead of the
source file.
- DPU. Preparsed unit. It can be used instead of the PAS files.
- TXT. File with topic descriptions in the light-weight XML
format, can be used to retrieve source code items' descriptions.
dHelp automatically generates and
updates the following pages for the every item parsed from your source
code:
- Unit description. Contains
brief and long description of the unit, list of procedures, functions,
classes, types, interfaces and variables declared in this unit
and 'See Also' section. You only need to specify brief and long
description, all other parts of the page will be generated
automatically. When unit is changed, dHelp rebuilds the page
automatically taking into account all changes you did in the source
(new items will be automatically added, not-existing items removed and
so on). Look at the picture.
- Class/Interface description.
Contains brief and long description of the class or the interface,
it's declaration, links to the pages with list of properties, methods
and events declared in this class, link to the inheritance graph, and
optional 'See Also' link. You need only to fill the brief and long
description of the class, all other items will be generated
automatically. When class declaration is changed, dHelp
automatically rebuilds the page changing class declaration,
property/event lists and other items taking into account all changes
you did with the class. Look at the picture.
- Type description. Such pages
are created for the every type (not class or interface) parsed from
your source code. Page includes type declaration as declared in the
source code, brief and long descriptions of the type and optional link
to the 'See Also' page. All these items are constructed automatically
and all you need to fill are brief and long descriptions of the type.
Like any other pages, type descriptions are automatically updated by
the dHelp when type declarations are changed in the source
code.
- Variable/Constant
description. Such pages are created for the every
variable and constant declared in your source code. Variable/Constant
description are constructed and updated automatically like any other
page and all you need to do is to enter once brief and long
descriptions. Look at the picture.
- Property description. Such
pages are automatically created for the each property (declared in the
published, public or protected sections) of the each class parsed from
your source code. Page includes brief and long description of the
property, property declaration as in source, link to the class where
this property is declared and optional link to the 'See Also' page.
Property type will be automatically marked as link to the page where
this type is described (even to the VCL help). All items of the page
except brief and long descriptions are created and updated
automatically. Property description pages are automatically linked
from the 'Class description pages'. If some property is not described
in the class but is described in the parent class, dHelp will
automatically include descriptions of this property from the parent
class, thus saving your valuable time. Look at the picture.
- Method/Event description.
Such pages are automatically created for the each public or protected
method and event of the each class parsed from your source code. Pages
contain brief and long description of the method/event, method/event
declaration as in your source code, name of the class where
method/event is declared and optional link to the 'See Also' page.
Like any other page, Method/Event descriptions are created and updated
automatically by the dHelp. All you need is to write brief and
long description for the method. If there are no descriptions for the
virtual method or for the event in the class but method/event is
described in the parent class, dHelp will automatically include
it's descriptions from the parent class, so you don't need to describe
your methods and events more than once. Types of the method and event
parameters in the declaration will be automatically linked with type
description pages (even with the VCL help). Look at the picture.
- Procedure/Function
description. Such pages will be automatically created for the
every global procedure and function found in your source code. Pages
contain brief and long descriptions, procedure declaration as declared
in the source, name of the unit where procedure is declared and
optional link to the 'See Also' page. All parts of the page are
generated automatically and you only need to fill brief and long
descriptions. When procedure declaration is changed (added or removed
parameter, moved to the other unit, etc.), procedure description page
will be automatically updated by the dHelp. Types of the
procedure parameters are automatically linked with the type
description pages (even if they are in the VCL help). Look at the picture.
- Inheritance graph. Pages with
inheritance graph are built for the every class and interface parsed
from your source code. These pages are automatically linked from the
class/interface description pages. They contain list of classes from
which the class is derived (down to the TObject) and list of parent
interfaces for the interface (down to the IUnknown) with the links to
the pages where these parent classes/interfaces are described (even if
in the VCL help). Inheritance graph pages are automatically updated
when class or interface inheritance is changed in your source code.
Look at the picture.
- See Also pages. 'See Also'
sections can be generated for the any item. You need to declare
see also lists in the simple format and dHelp will use
information that you provided and include see also items only if they
are valid (found in the source code and point to the described source
code items). Look at the picture.
- Lists of properties, events and
methods for the class and list of methods for the interface. Pages
with these lists are automatically generated for the each class and
interface parsed from your source code. Items are categorized into the
sections by the class/interface membership (from the class down to the
TObject and from the interface down to the IUnknown) and sorted
alphabetically by the name within the category. For every item an
image is shown (so you can quickly identify in what section
(published, public, protected or private) item was declared). Legend
page with image descriptions is linked from the page. Every item is
automatically linked to the item's description page (if any). Lists
pages are automatically linked from the class/interface description
pages under the 'Properties', 'Events' and 'Methods' links. Look
at the picture.
dHelp
automatically generates
and updates the following contents sections:
- Alphabetical classes list.
Every class found in your source code will be automatically
included into this section and linked with the page where this class
is described. Classes will be sorted alphabetically by their names and
grouped in optimal groups by specified rules. Look at the picture.
- Alphabetical interfaces
list. Every interface declared in your source code will be
automatically included into this section and linked with the page
where this interface is described. Interfaces will be sorted
alphabetically by their names and grouped in optimal groups by
specified rules. Look at the picture.
- Alphabetical types list.
Every type (not interface and not class) parsed from your source code
will be automatically added to this section and linked with the page
where this type is described. Types are sorted alphabetically by their
names and grouped in optimal groups by specified rules. Look at the picture.
- Alphabetical procedures
list. Every global procedure and function declared in your
source code will be automatically inserted into this section and
linked with the page where this procedure is described. Procedures
will be sorted alphabetically by their names and grouped in optimal
groups by specified rules. Look at the picture.
- Classes and procedures
by units. This section contains list of units that were
parsed and under the unit name list of classes, types, variables,
constants and global functions and procedures. All information is
added automatically and organized into the easy to use way. Look at
the picture.
dHelp creates variety of the
diagnostic information during process of the help generation:
- Bad links report. This report
includes all not resolved links (in 'See Also' and in topic's body) to
the source code items (procedures, classes, etc.) that were not found
in the source code.
- Compiler output report.
This report contains all output information displayed by the CHM help
compiler during it's work.
- Not complete
descriptions report. Lists topics for the source code
items (procedures, classes, etc.) which are partially described (no
brief or long description).
- Not described report.
Contains list of not described source code items (classes, procedures,
etc.)
- Performance report. Shows
effective size of the descriptions and can be used for the calculation
of the performance and productivity of your tech-writers.
dHelp has an advanced source code parser which
automatically retrieves declarations for the classes, interfaces,
procedures, properties and all other source code elements.
- Parser is capable enough to parse full-featured Delphi 5 (as well as
source code for other Delphi versions) units.
- Parser understands comments, conditional defines, includes and other
advanced preprocessor parts.
- It is possible to specify default include paths, defines, ignored
defines, unit aliases. All like in Delphi and even more!
- Parser can parse your source code as if it's parsed under Delphi 2,
Delphi 3, Delphi 4, Delphi 5, Delphi 6, C++ Builder 1, C++ Builder 3 or C++
Builder 4, following all the rules, which has the specific compiler
version.
- For the quicker access parser creates precompiled headers (like
Delphi creates DCUs), which are used during the next parse processes.
Subsets
of the help file can be defined and generated:
- You can define subset of source code units for which topics will be
included into the help.
- You can list source code elements (class, procedure, property, etc.)
and units that should not be included in the help.
- You can specify list of topics for which help file should be
generated.
- You can specify which declaration sections should be included
(include protected properties or not, etc.)
You can write similar descriptions only once
and you can have flexible 'See Also' section.
- When some method or property or procedure with completely different
name and declaration has the same descriptions (well it usually
happens), you don't need to describe it the second time. Just specify
description as 'alias' and point to the original description. When
help is generated, dHelp will take the original description and
change declaration to the right one but preserving the description
part of the topic.
- If some property or virtual method is described for the parent class
but is not described for the child class (or interface), dHelp
will take the description from the parent class, changing declaration
if needed.
- 'See Also' section is also processed very smart. You can omit unit
name before procedure name, class name before property or method name.
Even more dHelp will check your 'See Also' and will remove from
it not yet described topics or items which point to not existing
source code elements.
Powerful but easy to use interface as you want it:
- Command line. The most advanced method of the program
execution, allows to control every aspect of the work. We made command
line syntax very easy to use and described everything in the manual.
- GUI. GUI version is really easy to use and it's very
cute.
dHelp can be seamlessly integrated with other help
generators and used together with them to achieve even more results.
- dHelp can generate helps in the RTF file prepared for use
with other help generator programs (this RTF file will contain
necessary tags which define topics, hyperlinks, etc.). This RTF file
will contain all topics for all your source code items (classes,
procedures, properties, etc.).
- dHelp can be used together with HTML Help Workshop (a
freeware Microsoft product). dHelp can prepare all input files
(HTML, HHC, HHI, HHP, etc.) for all source code elements (classes,
procedures, properties, etc.), so you can switch to this tool and use
it on the later stages.
- dHelp can be used together with Help Workshop (a freeware
Microsoft product) . dHelp can prepare all required input files
for it (HPJ, CNT, RTF, etc.) for all source code elements parsed from
your source code.
The sweetest things.
- It's freeware. You don't need to pay anything to us for usage
of the dHelp.
- Manual included. dHelp comes with detailed manual
where every aspect of the program is described (and with examples).
There is also 'Quick Start' section, so you can find out how to use
dHelp very quickly.
- Good support/quick bug fixes. We support dHelp, it
means we will fix reported bugs and will add new functionality there.
We developed dHelp for our own purposes and continue to improve
it.
|
|
|
