Help Builder is a powerful tool for generating help.
This page describes some Help Builder's features in
more detail. In addition you'll find more information
on:
Here's why you should take a look at Help Builder:
- Visual IDE
Help Builder's environment is very similar to the HTML Help files you
will create with a content tree you add topics to and a topic editor you
use to enter topic content into. Live previews let you see what your help
file will look like at any time while building your help file is only a
click away. The interface is logical to use and intuitive to the point of
making Help creation easy and (almost) fun.
-
Template Driven
Documenting applications is often a dreaded task for developers because it
involves creating the actual help content as well as laying out the topics
visually. The idea is: You type plain text, the templates handle the
markup! You only use markup for special highlights which typically are
minimal.
Help Builder's template driven output lets you focus on creating content
while still giving you full customization options. For presentation, HTML
templates can be customized for default and custom topic types that you
create. Each topic type can have its own display attributes. The beauty of
this template approach is consistency and separation of the content from
the presentation making it much quicker to generate help files.
-
Cascading Style Sheets
Style sheets let you customize the visual aspects like fonts and
background colors for the entire help project in one place giving your
project a consistent look. At the same time you can override the
styles as needed on a by topic basis if necessary using plain HTML markup.
And best of all it's based on Web standards using standard HTML with
ASP-like markup for templates and even powerful template scripting.
- Customization
Help Builder was built with developers in mind and you can customize
just about every aspect of the help building process. Templates are
programmable with script tags so you can create sophisticated
functionality like topic driven tables and conditional field display with
ease. The entire IDE and the help engine itself is accessible via a COM
object. You can use your own HTML editors if you like or edit text inside
of the IDE. The list goes on.
- Structured environment
Structure is usually not a flattering word but in the Help building
environment it helps to fill in the blanks instead of creating content
from scratch each time. Help Builder's field based input allows you to
build help topics in record time. And if you feel too confined, switch to
WYSIWYG editing in live HTML view, or shell out to Word and keep on
writing your text there. Structure with flexibility to give you the best
of both worlds.
- Ease of use
Help Builder is easy to use! The IDE is self-explanatory with the help
file like structure and a powerful toolbar that provides access to most
functions visually. Powerful Wizards help create topics quickly and are
smart enough in aiding you by making common selections for you. Building a
simple help file will take only minutes...
- Many output options
Help Builder outputs to HTML Help File (CHM), a full HTML view
including a frames based interface for browsing the help file online, and
output to MS Word 2000.
- Developer Tools
Help Builder is also very strong for building developer documentation.
Class and database importing for various environments is supported for easy
pick up of your existing work. Visual FoxPro developers also get direct integration of
Help Builder into the IDE with ContextId updating directly from Help
Builder topics to interface controls. And Help Builder is fully COM
enabled so you can create projects, add and manage topics through a
programmatic interface.
- Import Classes and Databases
If you're like us and you develop applications and components Help
Builder can really help with that too. Help Builder imports the following.
Classes:
.NET Classes and entire Assemblies
COM Classes and entire Type Libraries
WSDL based Web Service Classes
Visual FoxPro classes and entire Class Libraries
Databases:
Sql Server tables and entire DataBases
Visual FoxPro Databases
All imported information can be further edited and if you're using C# you
can even write updated information right back into the source files.
-
Developer Tool Integration with Visual Studio .NET
Help Builder integrates with Visual Studio .NET and provides the ability
to pull in HelpStrings directly from Help Builder into your Windows Forms
applications. In addition C# developers can also directly import class
members from source code and write out XML Documentation from Help Builder
topics. We also provide a
custom HelpBuilderHelpProvider which you can use to pop up Help Builder
at runtime to edit Help Topics in the proper context of the active
control/form that requests help content.
-
Developer Tool Integration with Visual FoxPro
Visual FoxPro developers can also pop up Help Builder ontop of their
desktop forms and automatically pull in Help Context Ids. Help Builder can
also pop up at runtime to provide context sensitive access to topics for
editing.
- Tools, Tools, Tools
We built this tool because we need to build help files ourselves. In
fact, one of our products has over 1500 topics of documentation. To
facilitate creating and managing this process we've needed a number of
tools to make creating help easy. We've included, topic sorters, bad link
search utility, a screen capture utility, a custom icon manager, a flexible template manager, flexible linking tools
with auto-complete, XML
based exports and drag and drop, template schemes to allow you to have
several different looks for the same content and the list goes on.
So, to make a long story short - check out Help Builder and see for
yourself if it won't help you build Help files faster and more productively
than you have before.
Visual IDE
Help Builder's visual IDE resembles the HTML Help
engine so developers should feel right at home creating new topics and
inserting them into the hierarchical content tree of a Help Builder Project. A
variety of Wizards simplify common tasks like creating new topics, helping
generate default information automatically. Once added, topics can be edited
using plain text for fast typing or in full visual HTML view. Topics are
immediately available for preview either in an external IE window (in real
time) or using the built in HTML viewer. Below is a screen shot of the IDE in
visual preview mode for a topic:
(click on any image to see full screen shot)
In this mode you can browse the help file and see the
actual output generated into a browser preview. The HTML is fully functional
including all crosslinks that send you off to other topics. In order to edit a
topic you can switch into edit view, which allows you to modify the contents
of a topic. In edit view several pages allow you to customize each topic:
Here a plain topic is edited non visually. Note that
the main text is typed as plain text and all HTML mark up is marked up with
special HTML tags that have << >> tags. This allows Help Builder
to use standard formatting for line breaks, special characters without your
having to type complex HTML codes. You can insert most common HTML markup text
from the HTML Editing toolbar simply by highlighting a selection and then
choosing a menu option or hotkey for the markup operation. Any custom HTML
markup can be typed in manually.
Note that Help Builder will preserve any standard
single tag HTML and XML and actually display it as HTML rather than trying to
evaluate it. This is important for developer documentation that must include
HTML or XML as part of topic content.
Each help topic contains a variety of fields for
providing main topic text, related links, keywords providing a structured
approach to help building. For component developers a special Class tab allows
providing specific information about class methods, properties and events. For
plain text topics all topic content will be typed into the main body field as
above. For classes or components you will want to supplement this information
with information available on the Class tab:
This input format facilitates the process of creating
class documentation by following a standard format. Notice that the text you
type is considered 'formatted' HTML. This means you don't have to type in HTML
tags for things like line breaks or special characters like <> etc.
Formatted HTML markup can be embedded with double tags instead:
<<b>> for example. If you'd rather use 'Raw HTML' you can do so
easily by including <!-- RAWHTML --> at the top - you can then paste
HTML you create from other application such as FrontPage.
To create a new topic use the New Topic Wizard. The wizard asks different
questions depending on the kind of topic you want to create. For plain topics,
it simply asks for a new topic title. If you're building developer
documentation for components or classes the Wizard asks for an optional method
prototype to pre-generate much of the topic data quickly. The following figure
shows how a class method is added:
The New Topic Wizard is smart in that it bases its
questions based on what topic type you create. The class method dialog is
brought up only for properties and methods of class. For plain topics it skips
this page. The Wizard also makes guesses about the types of topics you will
want to create based on the current topic that you're starting from saving you
valuable time when creating new topics.
Template Driven
Help Builder supports the concept of topic types which
are used to describe and group the content of a particular help topics. By
default, the following topic types are provided: Header, Topic, ClassHeader,
ClassMethod, ClassProperty, ClassEvent, Index. Each of these topic types
corresponds to a template that is used to render the particular topic. You can
create your own topic types and create a custom template as well as providing
a custom icon for your topic type.
Help Builder is entirely driven through customizable
HTML templates. A template exists for every topic type in a Help Builder
project - users can create custom topic types to handle special display needs
for each type. Templates are plain HTML files with embedded ASP style script
code that reference the individual Help fields. It's possible to embed custom
script code and utilize the Help Builder COM object model to provide
sophisticated custom functionality - for example to create a method/property
list table for class headers. Several custom templates that demonstrate this
functionality are provided. Here is a template for the classheader displayed
in Visual InterDev:
Note that the actual help topic content is embedded
into the template using the ASP like script tags that access the Help Builder
COM object (oHelp). For example to access the Body you'd use oHelp.oTopic.Body.
Default templates are provided, but you can
customize these or even create brand new ones. For example the following code
creates a class property/method table for a class dynamically when the topic
is generated:
This generates a table like this automatically from a
class and its members:
You simply create your class and this table auto
creates when the help topic is rendered! As you can see the scripting language
in combination with the COM object is extremely powerful in providing
functionality for your templates.
<%
cCurrentPk = oHelp.oTopic.Pk
cHTML = ""
cClass = Alltrim(oHelp.oTopic.Class) + "::"
oTopics = oHelp.GetTopics("ARRAY","ParentPK = '" + oHelp.oTopic.Pk + "' and INLIST(type,'CLASSMETHOD','CLASSPROPERTY','CLASSEVENT')",;
"type,uMethod","ParentPk,Pk,upper(method) as UMethod")
If !ISNULL(oTopics) AND oTopics.nCount > 0
cHTML = cHTML + "<H3>Properties, Events and Methods</H3><p>"
cHTML = cHTML + "<table style='font:normal normal 9pt Verdana;background:White' border=1 cellpadding=2 cellspacing=0 align='center'>"
cHTML = cHTML + "<tr style='color:white;background:black'><td Width ='90'><b> Name</b></td>"
cHTML = cHTML + "<td Width ='75'><b> Type</b></td>"
cHTML = cHTML + "<td Width ='350'><b> Description</b></td></tr>"
For lnLoop = 1 To oTopics.nCount
oHelp.LoadTopic(oTopics.aTopics[lnLoop,2])
cHTML = cHtml + "<tr><td Align = 'Left' VAlign = 'Top'>" + TopicLink(oHelp.oTopic.Method,oHelp.oTopic.Topic) + "</td>"
cHTML = cHtml + "<td Align ='Left' VAlign ='Top'>"
Do Case
Case oHelp.oTopic.Type="CLASSMETHOD"
cHTML = cHTML + "<img src='bmp\ClassMethod.bmp' align=left> Method"
Case oHelp.oTopic.Type="CLASSPROPERTY"
cHTML = cHTML + "<img src='bmp\ClassProperty.bmp' align=left> Property"
Case oHelp.oTopic.Type="CLASSEVENT"
cHTML = cHTML + "<img src='bmp\ClassEvent.bmp' align=left> Event"
EndCase
cHTML = cHTML + "</td>"
cHTML = cHTML + "<td VAlign='Top'>"
lcBody = oHelp.FormatHTML(oHelp.oTopic.Body)
nBreak = AT("<p>",lcBody)
IF nBreak = 0
nBreak = AT("<br>",lcBody)
EndIf
IF nBreak > 1
cHTML = cHTML + LEFT(lcBody,nBreak - 1)
ELSE
cHTML = cHTML + lcBody
ENDIF
IF INLIST(oHelp.oTopic.Type,"CLASSMETHOD","CLASSEVENT")
cHTML = cHTML + "<br><b>" + oHelp.oTopic.Syntax + "</b>"
ENDIF
cHTML = cHTML + "</td>"
EndFor
oHelp.LoadTopic(cCurrentPk)
cHTML = cHTML + "</table><p>"
Response.Write( cHTML )
EndIf
%>
Generating output
Once you've created your topics you're
probably ready to create your help file. The Output Wizard takes your help
project and builds a
complete directory of HTML files from the topics. It also creates the HTML Help Project,
Index and content files based on the file, generating keywords and cross links
automatically.
HTML Help Builder work completely with HTML and the
output generated is plain HTML, which is then compiled into a HTML project and final CHM
file. The intermediate HTML files can be used directly - all crosslinks will still work.
Help Builder also, builds a standard HTML Help project that can be directly loaded into
Microsoft HTML Help Workshop. While, Help Builder provides most of the functionality of
Workshop, you can use Workshop for customizing the look of your HTML Help console for the
project - which topic is active, how big the Help form is on start up, what buttons to
include etc.
The CHM file looks and works just like it does inside of
Help Builder (with the exception of standard icons, which cannot be configured by
individual topic):
Tools to help you get the
job done!
Help Builder provides many useful tools for building
Help files quickly from drag and drop topic moving, support for Cascading
Style Sheets for consistent layouts, live previews, automatic related link
creation, auto creation of context ids, auto-complete topic selection,
exporting and importing of subtopics to XML or Help Builder project files and
a handy utility to find and fix bad internal links.
For creating developer help for components quickly
Help Builder supports importing of COM type libraries and Visual FoxPro
classes. Any information in these modules such as method and property names,
comments, parameters and return values are automatically added to the topic
list.
Help Builder generates HTML Help CHM files, plain HTML
output and creates an HTML Help Workshop compatible project. Help Builder can
also export to Word 2000 with custom templates to allow using a single help
project to generate both HTML Help and printable documentation.
Help Builder's object model is exposed via COM and can
be used to programmatically manipulate both the Help Project and the Viewer's
interface to drive Help Builder from any COM enabled development IDE. Visual
FoxPro IDE hooks are provided to allow automatic insertion of Help Context IDs
and automatic topic lookup. A VB add-in for Help Builder was not ready at
release time, but will be shipping by the end of the year.
Help Builder COM
Interface
Help Builder also exposes the entire Help Project
and generation engine as a COM object that you can use directly from your applications.
This makes it possible to retrieve individual pieces of a topic either as text or as
fully formatted HTML in the browser. You can use the COM object to open a project, load
topics and retrieve the HTML for a topic as a string, or force the topic to be displayed
in your browser or a Web Browser control. You have full access to each topic aspect like
topic, body, syntax, class, method, parameters, keywords etc. that make up the individual
fields of the help project file.
The following code demonstrates how to manipulate the
wwHelp.wwHelp object using COM code in VBA:
oHelp=CREATEOBJECT("wwHelp.wwHelp")
*** Open the help project - Force to reopen
oHelp.Open("c:\temp\wchelp\wchelp.hbp",True)
oHelp.LoadTopic("Class wwIPStuff",1)
*** Assign a template to use for rendering
oHelp.SetTemplate()
*** Return an HTML string of the topic
lcHTML = oHelp.RenderTopic()
*** Display topic in browser
oHelp.Preview()
*** Display topic in a Web Browser Control
oHelp.Preview(loWebBrowserCtl)
*** Properties
lcProjFile = oHelp.cFileName
*** oData Member contains topic data
lcTopic = oHelp.oTopic.Topic
lcBody = oHelp.oTopic.Body
lcPK = oHelp.oTopic.PK
*** Update the topic values
oHelp.oTopic.Topic = Form1.edtTopic
oHelp.oTopic.Class = Form1.edtClass
oHelp.SaveTopic() 'write to disk
*** Retrieve Topics - using a filter
loResult = oHelp.GetTopics("ARRAY","class='wwhelp'")
*** Loop through retrieved topics
FOR x=1 to loResult.nCount
IF oHelp.LoadTopic(loResult.aTopics[x,2])
? oHelp.oTopic.Topic
ENDIF
ENDFOR
