- Key Features
- Technical Requirements
- Advantages over old Together DocGen
- The Lite Edition
- Why to buy it?
DocFlex/Together is a revolutionary template-driven documentation generator for
based on DocFlex Technology.
Created under leadership of the former author of the
template-driven DocGen module
in Together (which was developed during 1998-2000 yet in
this new tool represents a major breakthrough and next logical step over
what Together DocGen was and
still is now.
The software includes:
The DSM drivers connect to Together models and present the information
from them in the form similar to XML documents, which can be further processed
by DocFlex generator using templates. The result is the best quality printable or
hypertext framed documentation for projects and models designed in Together.
The whole packages is prepared as a normal Together component and can be invoked both
from the Together IDE
and from the command line
in a batch mode. The template designer can also be
as a separate Java application without launching the whole Together IDE.
Please, see Examples
to take a look on how all this works.
2. Key Features
Represents Together models in the form similar to XML documents and allows
to process information from them basing on universal concepts of XML and approaches
developed around it (such as XPath).
capabilities comparable with those of
(and possibly even beyond).
The high quality graphic Template Designer
allows to visually design the sophisticated formatting
of the generated documentation basing on abstract layout concepts such as flow of text,
paragraphs, tables and lists and any combinations of them.
Since all such layouts in one or another form are supported by any modern output format
(such as HTML, RTF, PDF, XSL-FO and so on), the formatting specified in the DocFlex template
can be rendered with the high precision in any of those formats. (Currently, the supported
include HTML and RTF. Other formats are planned in next versions, XSL-FO in the first place).
The TXT output is supported as well and may be used for non-documentation
tasks to employ sophisticated data query and processing capabilities presented
in this technology (for instance, using templates and TXT output, you can easily
program dumping the data from Together models into various XML files).
DocFlex templates are full-blown programs. What is not visualized by
the Template Designer in the form of
can be specified in component properties using FlexQuery-expressions.
are small scripts with the Java-based syntax, which are widely used in DocFlex templates to specify
all kinds of dynamically computed settings (such as dynamic
properties of template components,
filter conditions and so on).
About 150 built-in general utility functions are available now within the expressions,
plus 26 function specific for Together, which represent some functionality provided
by Together OpenAPI.
A special utility function
callForName() allows to invoke a method of
any custom-written external Java-class (implementing a special interface from the
Within FlexQuery-expressions, it is possible to access the
as well as various generator variables organized in the form of hierarchy of objects and properties
of the Generator Object Model (similar to Document Object Model in Dynamic HTML).
The basic set of templates
provided with DocFlex/Together (both editions) allows to generate
the following kinds of documentation:
The notable feature of the Diagram Documentation generated in RTF output format is that,
all diagram images
are properly scaled to fit the page size. Moreover, big diagrams will be
automatically rotated into "landscape" orientation
in order to minimize the
(this feature can be disabled).
The detailed Class Documentation (similar to that produced by Javadoc), see
The Diagram Documentation for the following diagram types:
- Class Diagram (screenshot)
- Use-Case Diagram (screenshot)
- Component Diagram
- Deployment Diagram (screenshot)
- Sequence Diagram (screenshot)
- Collaboration Diagram
- State Diagram (screenshot)
- Activity Diagram (screenshot)
- Entity Relationship Diagram (screenshot)
- Business Process Diagram
- Robustness Diagram (screenshot)
- (Other specific diagram types available in Together will be supported for free
immediately as soon as you request any of them.)
The User Interface Documentation (Together 6.x or Together Architect 1.x only),
Provides comprehensive support for launching the documentation generator
from the Together command line.
This includes possibility to specify on the command line:
3. Technical Requirements
DocFlex/Together (both full and lite editions) works with:
To run the
Template Designer as separate application,
you will need Java™ 2 JRE 1.4.x or JRE 1.3.x.
- Borland® Together® Architect version 1.x
- Borland® Together® ControlCenter™ version 6.x or 5.x
- Borland® Together® Solo version 6.x or 5.x
The DocFlex/Together Java libraries are supplied in two variants
(both included in the packages available in downloads):
Under JRE 1.4.x, the Generator
shows much faster performance (although, this can be used only with Together 6.2 or Together Architect 1.0).
- The one optimized for JRE 1.4.x
- The another one compiled for JRE 1.3.x.
4. Advantages over old Together DocGen
DocFlex/Together offers the following major advantages over the old DocGen module in Together:
A new data model concept. Now, it is not based anymore on the Together specific notions (namely,
things described by RWI interface of Together OpenAPI). Instead, DocFlex, in any its incarnation, always "thinks"
it works with an XML document. This allows to organize all data querying basing on XPath as well as gives
other immense possibilities of data processing -- virtually to turn inside out any data fed to DocFlex with
just a few settings specified in templates!
Also, this approach provides a single platform independent on any particular application.
As you can see on this web-site, we offer now a similar tool for Javadoc called
DocFlex/XML is another our product based on this technology.
This tool allows to construct templates using data type information obtained
from DTD and XSD (XML Schema) files and process data directly from XML files.
The next step about it will be creating with the DocFlex/XML
a set of templates specifically designed for
OMG XMI® data sources
(that is XMI files). In effect, this will provide a universal template-based doc-generator
for virtually any modern UML modeling tool with all included XMI-specific templates open for
the users to change!
Another huge advancement over the old DocGen is absolutely new formatting concept.
In the old DocGen, all formatting within templates was specified in notions of coordinates.
This was difficult and sometimes simply impossible to render correctly in such layout-based formats
as HTML and RTF.
In DocFlex, on the contrary, all
formatting is directly specified using layouts
flow of text,
This smoothly fits into the container organization of Java Swing components as well as all known output formats
(HTML, RTF, PDF and so on). The result is that what you see in the Template Designer, you'll get
in output documents.
Also, this approach allows using the same abstract formatting once specified in the templates
to generate the outstanding quality documentation simultaneously in all output formats
supported by DocFlex (see screenshots).
There are lots of other advancements which could make life easier for developers using DocFlex
such as full support of
all generator variable organized in the form of the Generator Object Model
(similar to Document Object Model in dynamic HTML), about 100 general utility functions
available in FlexQuery-expressions,
which are small scripts widely used in
to specify all kinds of dynamically computed settings.
The open part of DocFlex API will allow to smoothly integrate the calls to DocFlex generator
into your own Java code. The open API will allow:
The open DocFlex API will be fully documented shortly (with the release of version 1.1).
- To launch the DocFlex generators to interpret the specified templates from any Java application.
- To pass any parameters to the templates programmatically as well as by invoking the parameter
- To extend your templates with the custom-written Java classes (called from within templates
via 'callForName' function).
5. The Lite Edition
“DocFlex/Together Lite” is a reduced version of
DocFlex/Together without the
The basic templates are built into the executable Java library as resources.
So, you can use this software simply as a high quality documentation generator for
without knowing much about how all this internally works.
In addition, the Lite Edition allows to execute any other external templates created
with a licensed copy of the DocFlex Template Designer (included in the full version).
6. Why to buy it?
We suggest the following reasons for purchasing a license for DocFlex/Together
and starting using it:
DocFlex is a state-of-the-art technology which in total
took more than 10000 man/hours to develop. No one vendor offers now
anything like this!
A rare opportunity to upgrade one of the key features of
a UML modeling tool for a very cheap price.
This product is not the dead one. It is a live source!
By purchasing a license for this software, you not only acquire a useful tool,
you also make a vital investment into its future development which results
you could enjoy later by yourself. And we do know where to go next!
We provide agile support for your license no big company could ever boast!
You could ask us any your questions and receive comprehensive answers
on them directly "from the source" -- that is from the very people who have
conceived and developed this technology.
Moreover, we are able to instantly fix any bugs you report
as well as quickly update this tool to meet your needs.
Because what is useful for you will certainly be useful for others!
In fact, this is what we most need now -- to have a direct contact to
people using our tools and be able to track what improvements are needed,
what the real demand is.
We offer help in designing your templates to customize
the generated documentation by your order.
See also our Services.