To complete the installation, open a command prompt and run the Ant integrator build file from your DITA-OT directory
(ant -f integrator.xml).
Authoring
The structure of a cshelp DITA file mirrors that of an Eclipse contexts file. A contexts file is an XML file that contains
one or more context elements inside a containing <contexts> element. Each context element contains a unique ID, the
text of the Context-Sensitive Help topic, and optionally, links to Help topics in the Help system.
<?xml version="1.0" encoding="UTF-8"?>
<?NLS TYPE="org.eclipse.help.contexts"?>
<contexts>
<context id="new_wizard_selection_wizard_page_context">
<description>
Choose the type of resource you would like to create.
</description>
<topic label="Resources" href="concepts/concepts-12.htm"/>
</context>
</contexts>
Similarly, a cshelp DITA file contains one or more cshelp elements inside a containing <cshelp> element (which is
otherwise unused). Each nested cshelp element contains a unique ID, text, and related links.
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE cshelp PUBLIC "-//OASIS//DTD DITA CSHelp//EN"
"..\demo\cshelp\dtd\cshelp.dtd">
<cshelp id="csh_outer_container" xml:lang="en-us">
<title>sample1_context</title>
<shortdesc></shortdesc>
<csbody></csbody>
<cshelp id="new_wizard_selection_wizard_page_context">
<title></title>
<shortdesc>Choose the type of resource you would like to create.</shortdesc>
<csbody>
</csbody>
<related-links>
<link format="htm" href="concepts/concepts-12.htm" scope="peer">
<linktext>Resources</linktext>
</link>
</related-links>
</cshelp>
...
</cshelp>
It is important to note that the only highlighting markup that can be used inside Eclipse Context-Sensitive Help is the
bold (<b></b>) tag, and the only formatting options are the carriage return and the space key. All of these are permissible
only inside the description element. When sourcing Context-Sensitive Help in DITA, all of the highlighting and formatting
markup options that are available in the shortdesc and body elements of the topic type may be used. The transform that
Draft | Developing DITA-based Help for Existing Help Environments | 11
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
creating bookmarks in pdf files; create bookmarks pdf file
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
create bookmarks in pdf; creating bookmarks pdf files
produces a contexts file from the DITA source produces output that conforms to the restrictions of the contexts file. In
most cases, the output approximates what would be seen in HTML output, but some DITA elements are simply ignored:
• Table and simpletable
• Image (only the text in the <alt> attribute or tag will display)
• Object
• Figure (only the text in the <desc> tag will display)
• Footnote
• Indexterm, indextermref
• Xref
Use as many DITA files per Eclipse plug-in that you want, and create a simple DITA map file inside the plug-in that
points to each of them. Include any copyright information in the DITA map; this information will appear in comment
tags in each generated contexts file. Note, however, that relationship tables (reltables) cannot be used to create related
links when producing Eclipse contexts files.
Integration
Refer to the Eclipse documentation for instructions on incorporating context IDs in code plug-ins. This information is
typically in Platform Plug-in Developer Guide > Programmer's Guide > User assistance support > Help > Context-Sensitive
Help > Declaring a context ID.
http://www.eclipse.org/documentation/
Output
When processing the DITA map file, there are two parameters that need to be set:
• Use the switch that identifies a separate XSL file, and point to the dit2context.xsl file in the cshelp/xsl
directory. For example, if you are using Ant:
<property name="args.xsl" 
value="${dita.dir}${file.separator}demo${file.separator}
cshelp${file.separator}xsl${file.separator}dit2context.xsl"/>
• Use the switch that indicates the output extension of the generated file will be XML. For example, if you are using
Ant:
<property name="args.outext" value="xml"/>
The contents of the generated XML file should resemble the example contexts file in the Authoring section.
Summary
Context-Sensitive Help is an integral part of the user assistance for software applications. If you already use DITA to
source your Eclipse documentation plug-ins, sourcing the Context-Sensitive Help in DITA allows you to maintain a
consistent authoring and build environment and consistently formatted output.
Jeff Antley
OASIS DITA Help Subcommittee
Context-Sensitive Help using the Enhanced HTML (htmlhelp2) Plug-In
This topic describes the htmlhelp2 plug-in for the DITA Open Toolkit.
12 | Draft | Developing DITA-based Help for Existing Help Environments
VB.NET PDF File Compress Library: Compress reduce PDF size in vb.
document file. Remove bookmarks, annotations, watermark, page labels and article threads from PDF while compressing. Also a preview
display bookmarks in pdf; how to add bookmarks to pdf document
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.
bookmarks pdf file; convert word pdf bookmarks
Overview
The process of generating Microsoft
®
HTML Help (CHM) output from DITA content using the DITA Open Toolkit
does not provide the abilty to store context-sensitive Help identifiers in the topics or in the ditamap. Context identifiers
have to be created and managed outside the DITA authoring enviornment. The htmlhelp2 plug-in created by Deborah
Pickett extends the DITA OT functionality to allow context-identifiers to be generated from values stored in the resourceid
attribute of the ditamap's topicref.
Setup and configuration
To install the plug-in, download the plug-in ZIP file from Yahoo! DITA Users Group  and extract the files into the
\plugins directory in the DITA-OT directory, and run the integrator task. The htmlhelp2 transtype will then be
available as an Ant build output.
The htmlhelp2 functionality is built into the ditaplus plug-in, also created by
Deborah Pickett.
Authoring
The plug-in uses the resourceid element within the topicmeta element in the topicref in the ditamap as the
basis for building the map and alias files required for HTML Help context-sensitive Help. The resourceid element
doesn't contain data, and has two attributes: id and appname. The id attribute can hold only value, whereas the
context-hooks in HTML Help require a string and a numeric indentifier. It is expected you will enter a numeric value
into the id attribute of the resourceid, and the plug-in will derive from that number a string value.
For example, an id of 3254 will be transformed to a map file entry of:
#define identity_3524 3524
In other words, the resourceid's id attribute is used as the context number, and used to create the context string by
prefixing the number with the string identity_.
In addition to entering a context number in the id attribute, you must also enter an appname attribute of
WindowsHelpId in the resourceid element in the topicref in the ditamap. The WindowsHelpId value
indentifies the particular resourceid as being used for context-sensitive Help, thus differentiating it from resourceid
elements used for other purposes.
You can have add more than one resourceid element if you need several different help IDs to be pointed to the one
topic.
How It Works
In Microsoft
®
HTML Help, map (.h or .map) files correlate context strings to context numbers, and alias (.ali) files
map context numbers to topic file names.
The htmlhelp2 transformation extracts from all topics in the ditamap any resourceid elements where the appname
attribute is WindowsHelpId. The map and alias files generated by htmlhelp2 are named [map_file_name].map
and [map_file_name].ali respectively.
Example
The following markup:
<map>
<title>Cat flossing </title> 
<topicref href="abc.xml">
<topicmeta>
<resourceid appname='WindowsHelpId' id='3524'/>
</topicmeta>
</topicref>
...
</map>
Draft | Developing DITA-based Help for Existing Help Environments | 13
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 template pdf; how to bookmark a pdf file in acrobat
C# PDF File Compress Library: Compress reduce PDF size in C#.net
NET framework. Remove bookmarks, annotations, watermark, page labels and article threads from PDF while compressing. C# class demo
copy pdf bookmarks; create bookmark pdf file
will produce the following map and alias file lines:
• map:
#define identity_3524 3524
• alias:
identity_3524 abc.html
Summary
The htmlhelp2 plug-in provides a simple method for generating HTML Help context
map and alias files from values entered in the resourceid element in the ditamap's
topicref.
Eclipse_CSH Plug-in for Dynamic Context-Sensitive Help
This topic describes the eclipse_csh plug-in for the DITA Open Toolkit (DITA-OT), which generates complete, deployable
Eclipse plug-ins that support dynamic context-sensitive help for Eclipse-based applications.
Eclipse plug-ins generated by the DITA-OT, with the eclipse_csh plug-in, provide dynamic context-sensitive help for
Eclipse-based applications that define abstract help contexts and use the ContextProviderDelegate (supplied by
org.eclipse.datatools.help).
Abstract help contexts allow UI developers to isolate the Eclipse help system's concrete help context ID strings and help
search expressions from the UI implementation (Java code). That gives user assistance (UA) content developers more
control over help contexts and context-specific content, so they can provide more useful, and more precisely targeted,
dynamic context-sensitive help.
Overview
The Eclipse help system uses two key pieces of data to find context-specific UA content for dynamic context-sensitive
help:
• A help context ID string, which associates a UI context with a particular chunk of context-specific content
• A context-specific help search expression, which the help system uses to find additional, related content in its online
documentation "library"
For many developers, one of the main problems with Eclipse dynamic context-sensitive help is the necessity to embed
help context ID strings and context-specific help search expressions in the UI code. That can reduce code portability,
and it forces recompiling whenever a help context ID string or a help search expression needs to be changed. It makes
UI implementation more cumbersome, particularly in an agile development (or RAD) environment. Unless all UI contexts
are explicitly specified, and frozen in advance, developers are tempted to delay implementing context-sensitive help to
avoid otherwise unnecessary recompiling and rebuilding.
By using the org.eclipse.datatools.help.ContextProviderDelegate (the DTP help-helper, provided by the Eclipse Data
Tools Platform project), and defining abstract help contexts in their code, UI developers are free to implement dynamic
context-sensitive help at any point in the UI development cycle.
By using the DITA-OT, with the eclipse_csh plug-in, UA content developers (writers) and information architects can
define the associations of help context IDs with UA content, using special context-sensitive help markup in a standard
DITA map that produces an Eclipse online documentation plug-in. Content developers are free to revise the UI-UA
context associations and context-specific help search expressions at any time, without impacting UI code.
14 | Draft | Developing DITA-based Help for Existing Help Environments
.NET PDF SDK - Description of All PDF Processing Control Feastures
Fully featured PDF Viewer in HTML5; Outstanding rendering of PDF documents; Full page navigation, zooming & rotation; Outlines, bookmarks, & thumbnail display;
creating bookmarks pdf; add bookmarks to pdf reader
XDoc.Word for .NET, Advanced .NET Word Processing Features
& rotation; Outlines, bookmarks, & thumbnail display; Integrated annotation; More about Web Viewer ▶. Conversion. Word Create. Create Word from PDF; Create Word
export pdf bookmarks to text file; pdf bookmark
Setup and configuration
The eclipse_csh plug-in is available from the DITA-OT project on sourceforge.net: [URL pending final release to open
source]
Download the eclipse_csh zip file (eclipse_csh_1.0.0.zip), and extract all files and folders into the plugins/ directory,
in a previously installed DITA-OT.
Run the DITA-OT integrator.xml Ant buildfile to complete the plug-in installation.
Authoring
Any DITA map document that defines an Eclipse online documentation (doc) plug-in can be modified to also define a
corresponding context-sensitive help plug-in, by inserting the appropriate context-related markup.
Note: The DITA map markup described in this section does not require any DITA specializations; it relies entirely
on standard DITA map elements and attributes.
Identifying the UI plug-ins associated with help contexts
DITA maps for context-sensitive help plug-ins must contain a <topicmeta> element as the first child of the <map>
element, and for each UI plug-in whose help context IDs are identified in the map, that <topicmeta> element must
contain one <othermeta> element that identifies the UI plug-in.
The <othermeta> element's name and content attribute values will be used to identify UI plug-ins in the
org.eclipse.help.contexts extension, which is declared in the plug-in manifest (plugin.xml file) of the context-sensitive
help plug-in. For example:
<map id="org.eclipse.datatools.ui.doc">
<topicmeta>
...
<othermeta name="ui-plugin"
content="org.eclipse.datatools.connectivity.ui"/>
<othermeta name="ui-plugin"
content="org.eclipse.datatools.connectivity.ui.dse"/>
</topicmeta>
...
</map>
The name attribute value "ui-plugin" is a fixed, literal string. The content attribute value is the Eclipse plug-in ID of a
UI plug-in.
Defining related topics associated with help contexts
DITA maps for context-sensitive help plug-ins contain <resourceid> elements, each of which identifies a concrete
help context ID associated with a DITA topic.
The <resourceid> element is a child of a <topicmeta> element. For example:
<topicmeta>
<resourceid id="help_context_ID_string"/>
</topicmeta>
For each DITA topic associated with a help context ID, the <topicref> element that points to that topic contains a
<topicmeta> element (with a <resourceid> child element). This defines the association of a help context ID
with that topic. For example:
<topicref navtitle="label attribute in contexts.xml topic element"
href="path/to/topic.xml">
<topicmeta>
<resourceid id="help_context_ID_string"/>
Draft | Developing DITA-based Help for Existing Help Environments | 15
XDoc.Excel for .NET, Comprehensive .NET Excel Imaging Features
zooming & rotation; Outlines, bookmarks, & thumbnail display; Integrated annotation; More about Web Viewer ▶. Excel Convert. Convert Excel to PDF; Convert Excel
export pdf bookmarks to text; add bookmarks to pdf preview
XDoc.PowerPoint for .NET, All Mature Features Introductions
& rotation; Outlines, bookmarks, & thumbnail display; Integrated annotation; More about Web Viewer ▶. PowerPoint Convert. Convert PowerPoint to PDF; Convert
bookmarks in pdf from word; how to bookmark a pdf file
</topicmeta>
</topicref>
Any DITA topic can be mapped to multiple help context IDs by inserting as many <resourceid> child elements as
necessary in the <topicmeta> element. For example:
<topicref navtitle="label attribute in contexts.xml topic element"
href="path/to/topic.xml">
<topicmeta>
<resourceid id="help_context_ID_1"/>
<resourceid id="help_context_ID_2"/>
<resourceid id="help_context_ID_3"/>
</topicmeta>
</topicref>
Other considerations for DITA maps that define context-sensitive help plug-ins:
• Markup for context-to-topic mapping is needed only for the DITA topics that will be context-sensitive help targets
(i.e., Related Topics shown in the Help view).
• When a single DITA topic appears more than once in a map, only the first instance of a <topicref> that points
to that topic needs the context-sensitive help markup.
• Nested maps that contribute DITA topics related to help contexts must include the same context-sensitive help
markup.
Context-specific help content
Each <topicmeta> element that wraps a <resourceid> element may optionally contain one <searchtitle>
element or one <shortdesc> element, or both (one of each), to provide context-specific help content.
• The <searchtitle> element is used to supply the value of the title attribute on the <context> element in the
Eclipse context XML file.
• The <shortdesc> element is used to supply the content of the <description> element in the Eclipse context
XML file.
For example:
<topicref navtitle="label attribute in contexts.xml topic element"
href="path/to/topic.xml">
<topicmeta>
<searchtitle>Optional text to override the help About 
title.</searchtitle>
<shortdesc>Text for context description.</shortdesc>
<resourceid id="help_context_ID_string"/>
</topicmeta>
</topicref>
Note: The <searchtitle>, <shortdesc>, and <resourceid> elements must appear in the <topicmeta>
element in the order shown above.
A DITA map that contains the example shown above produces the following content in an Eclipse context XML file:
<contexts>
...
<context id="help_context_ID_string"
title="Optional text to override the help About title.">
<description>Text for context description.</description>
<topic label="label attribute in contexts.xml topic element"
href="PLUGINS_ROOT/doc_plugin_ID/path/to/topic.xml"/>
</context>
...
</contexts>
16 | Draft | Developing DITA-based Help for Existing Help Environments
where doc_plugin_ID is the value of the id attribute on the <map> element.
Integration
To provide dynamic context-sensitive help, an Eclipse-based application must define the associations between its UI
controls and help contexts dynamically, by implementing methods of org.eclipse.help.IContextProvider. One of those
methods (getContext) must return a concrete help context ID string, which matches an IContext object contributed by
an extension of org.eclipse.help.contexts, and defined in an Eclipse context XML file. Another method
(getSearchExpression) must return a context-specific help search expression, if the application requires more targeted
search results than the default help search expression provides.
The DTP help-helper plug-in (org.eclipse.datatools.help) provides a "help key" extension point
(org.eclipse.datatools.help.helpKeyProperties), and supplies a context provider delegate implementation
(org.eclipse.datatools.help.ContextProviderDelegate).
• The helpKeyProperties extension point allows any plug-in to contribute ResourceBundle properties files that define
the mapping of abstract help keys to concrete help context IDs and help search expressions.
• The ContextProviderDelegate, along with abstract help keys, enables help context abstraction for any UI control that
implements methods of IContextProvider.
The eclipse_csh plug-in for DITA-OT provides the processing to generate context-sensitive help plug-ins, which serve
as companions to Eclipse online documentation plug-ins generated by DITA-OT (using its standard dita2eclipsehelp
transtype). Indeed, the dita2eclipse_csh transtype target depends on the dita2eclipsehelp target to first generate an Eclipse
online documentation plug-in.
Eclipse plug-ins produced by eclipse_csh handle the mapping of help contexts to context-specific help content, and
provide support for the DTP help-helper infrastructure by contributing:
• Eclipse context XML files, which supply the context-specific help content for each help context, and point to other
help topic contributions directly related to the help context
• Java properties files, which define key-value pairs that map abstract help contexts (helpKey constants) to concrete
help context IDs and context-specific help search expressions
Eclipse plug-ins produced by eclipse_csh do not contribute (or contain) any topic-based UA content. Their context XML
files refer to topics contributed by their companion documentation plug-ins.
Team collaboration
Successful delivery of Eclipse dynamic context-sensitive help requires close coordination of UI components and UA
components. It imposes responsibilities on both Development teams and Documentation teams, and it requires ongoing
collaboration.
Development teams are primarily responsible to:
• Implement the Eclipse classes and methods necessary to enable dynamic context-sensitive help for all appropriate
UI controls.
• Implement interface classes that declare helpKey constants for each UI plug-in.
• Provide lists of the helpKey constants to Documentation teams in a timely manner.
• Test the context-sensitive help UI implementation, with context-sensitive help UA plug-ins and online documentation
plug-ins provided by Documentation teams.
Development teams should provide lists of helpKey constants in the form of Java source files for the helpKey constants
interface classes. Java source files provided as helpKey lists must include appropriate help context comments to provide
information about each associated UI control.
Documentation teams are primarily responsible to:
• Develop context-specific help content and context-specific help search expressions for appropriate UI help contexts.
• Define the concrete help context ID strings that associate abstract help contexts with context-specific help content.
• Create the Java properties files that define the mapping of abstract help contexts to concrete help context IDs.
Draft | Developing DITA-based Help for Existing Help Environments | 17
• Create the context-sensitive help UA plug-ins that contribute Eclipse context XML files and the Java properties files.
• Test the context-sensitive help UA plug-ins and online documentation plug-ins, with UI components provided by
Development teams.
Documentation teams should rely on the Java source files (for the helpKey constants interface classes) as the original
and definitive sources of all helpKey constant strings.
Note:  Creating the Java properties files can be somewhat automated (e.g., by processing the Java source files with
a simple perl script).
Workflow
The following summarizes the Documentation team workflow to create Eclipse context-sensitive help plug-ins:
1. Get the helpKey list (provided as a Java source file) from the UI Development team for each UI plug-in.
2. Analyze the helpKey list and associated UI controls to define the help contexts.
The Documentation team must determine whether:
• The helpKey constants alone are sufficient to identify actual help contexts, and thus, a helpKey constant could
be mapped directly to a concrete help context ID, with the same string value as the helpKey constant.
• Distinct help context ID strings must be defined to combine groups of helpKey constants into common help
contexts.
Tip:  It may be preferable to combine help contexts in the helpKey properties file, instead of defining the
mapping for multiple help contexts to a single topic in a DITA map. This is a judgment call for the Documentation
team responsible for maintaining DITA maps.
3. Analyze the help contexts and existing (or planned) help topics to define context-specific help search expressions.
4. Create helpKey properties files, based on the content of each Java source file.
• Define the mapping of helpKey constants to concrete help context IDs and context-specific help search expressions,
based on results of the help context analysis and help topic (content) analysis.
• Save the helpKey properties files in source control, as appropriate.
Tip: The helpKey properties files are flat ASCII text files, so authors (or IAs) responsible for defining the help
context IDs and context-specific help search expressions should use a suitable ASCII text editor to create and
edit those files.
5. Modify existing DITA maps (if used to produce Eclipse online documentation plug-ins) to add the markup for
context-sensitive help.
6. Build Eclipse plug-ins, using the DITA-OT with the eclipse_csh plug-in, and test the Eclipse plug-ins with UI
components provided by Development teams.
Summary
Help context abstraction is a technique to simplify the handling of help context IDs and help search expressions in the
UI code, by abstracting them to "help keys."
Help context abstraction provides the following benefits:
• Development teams are free to associate new help contexts with UI controls, without necessitating that corresponding
help context IDs or help search expressions exist.
• Documentation teams are free to define UA help contexts, modify help context IDs, and control the mapping from
abstract help contexts to concrete help context IDs, without necessitating any change in the UI code.
• Documentation teams are free to define and modify context-specific help search expressions, and the mapping from
abstract help contexts to help search expressions, without necessitating any change in the UI code.
This separation of responsibilities enables the project team to provide higher quality, and more precisely targeted,
dynamic context-sensitive help.
18 | Draft | Developing DITA-based Help for Existing Help Environments
For more information about the DTP help-helper, see:
http://www.eclipse.org/datatools/doc/20080310_DTP_Help-Helper.pdf
Eclipse Help
This topic provides an overview of how to use the DITA Open Toolkit to develop content for the Eclipse Help system.
According to the Eclipse Web site, the Eclipse integrated development environment (IDE) is an "open source platform
comprised of extensible frameworks, tools and runtimes for building, deploying and managing software across the
lifecycle." Eclipse can be installed on Windows, Mac OS X, or Linux (32–bit or 64–bit).
The Eclipse Help system is itself extensible, allowing additional documentation to be delivered using Eclipse's plug-in
framework. It can be used in three different modes: workbench, standalone, and infocenter.
• Workbench mode is for documentation for tools integrated into the Eclipse IDE.
• Standalone mode serves a similar purpose, but is used for software that is not Eclipse-based.
• Infocenter mode allows the Eclipse Help system to deliver topics through the World Wide Web. Local instances of
the Eclipse Help system can also retrieve and integrate content from a remote server running Help in infocenter
mode.
The Eclipse Help system contains search and indexing features, allows the triggering of workbench actions or Eclipse
code from within Help topics, supports dynamic content and link filtering (when using XHTML), and supports
globalization. You can even use Eclipse to manage the development, building, and testing of your DITA-sourced
documentation plug-ins.
Overview
The Eclipse Help displays HTML- or XHTML-formatted topics, and organizes the topics according to the XML-formatted
Table of Contents (TOC) files that are provided in each plug-in that contains documentation.
For more information on developing Help for Eclipse, refer to the documentation for the current Eclipse release, available
on http://www.eclipse.org.
Setup and configuration
DITA Open Toolkit
The DITA Open Toolkit contains the transformations necessary to produce all of the files required for Eclipse Help
plug-ins. No special setup or configuration is necessary. Refer to installation and configuration instructions within the
DITA Open Toolkit to set it up.
Eclipse
Download Eclipse from http://www.eclipse.org. Installation involves unpackaging an archive file to any location on
your machine. A Java Runtime Environment (JRE) is required. Eclipse manages your development resources in
workspaces, that also can be any location on your machine. You are prompted to select or create a workspace location
to use each time you start Eclipse.
Eclipse documentation plug-ins
Documentation for the Eclipse Help system can be included in any plug-in, as long as the plug-in extends Eclipse's
org.eclipse.help.toc extension point. It is up to the individual organization whether to include documentation
inside code plug-ins or in their own plug-ins. There are several advantages to the latter, such as unambiguous ownership
or if content will be globalized.
Plug-ins are named according to Sun's Java package naming guideline (for example, org.eclipse.help). Plug-ins
that contain only documentation typically have .doc at (or near) the end of the plug-in name.
Draft | Developing DITA-based Help for Existing Help Environments | 19
Within a plug-in, two XML files are required in the root (a manifest and a table-of-contents (TOC) file). Any number
of content files may be included, in any location within the plug-in. The TOC file can be generated from a DITAMAP
file, and HTML files will be generated from DITA files.
Plug-ins can be delivered to the Eclipse run-time environment as folders or as Java archive (JAR) files. Documentation
within folders may exist in archives (for example, doc.zip). Archives cannot be nested (that is, a doc.zip cannot
be included in a plug-in delivered as a JAR file).
Authoring
Author DITA topics as you would normally. You can include any number of topic files, folders, DITA maps, or other
file-based resources that can be delivered within browser environment (for example, images or multimedia).
When creating links to other topics (XREFs or LINKs), note links to topics in other plug-ins should be coded as follows:
PLUGINS_ROOT/PLUGIN_ID/path/to/target.html
Where PLUGINS_ROOT/ indicates that the target file is in another plug-in and PLUGIN_ID is the ID of the plug-in
as declared in the manifest file. Refer to the Eclipse documentation regarding Help server and file locations in Help
content: http://www.eclipse.org/documentation/.
Integration
To integrate your content into Eclipse, manually create a plugin.xml file that points to one or more TOC files in the
plug-in, and a manifest.mf file (in a META-INF folder).
Plugin.xml file
This example plugin.xml file is similar to the one provided with the Garage sample in the DITA-OT. This example
shows the minimum amount of information required to declare a TOC file to the org.eclipse.help.toc extension
point.
<?xml version="1.0" encoding="UTF-8"?>
<?eclipse version="3.0"?>
<plugin>
<extension point="org.eclipse.help.toc">
<toc file="hierarchy.xml"/>
</extension>
</plugin>
Manifest.mf
In current versions of Eclipse, some of the manifest information, such as the plug-in ID, is separated into the
manifest.mf file. Manifest.mf is stored in the plug-in in a folder named META-INF For the Garage sample,
here is a possible manifest:
Manifest-Version: 1.0
Bundle-ManifestVersion: 2
Bundle-Name: Garage Plug-in
Bundle-SymbolicName: org.dita.garage.doc
Bundle-Version: 1.0.0
Note that what was the plug-in ID in the plugin.xml file is referred to as the Bundle-SymbolicName in the
manifest.mf file.
TOC file
TOC files are generated from DITA map files. You may include any number of TOC files in a plug-in, as long as they
are declared in the plugin.xml file.
From the Garage sample, here is hierarchy.xml:
<?xml version="1.0" encoding="UTF-8"?>
<?NLS TYPE="org.eclipse.help.toc"?>
20 | Draft | Developing DITA-based Help for Existing Help Environments
Documents you may be interested
Documents you may be interested