Products         News         Downloads         Licensing         Shop         Support    

 DocFlex Technology
Overview
Features
Documentation
 DocFlex/XML
Overview
Features
Documentation
XSDDoc
WSDLDoc
Integrations
 DocFlex/Javadoc
Overview
Documentation
Basic Templates
JavadocPro
Examples
Tutorials
 DocFlex/Together
Overview
Examples
Basic Templates
Documentation
Tutorials
 Try
Downloads
Registration
Trial License
 Use
Licensing
Shop
Support
 Company
News
Products
Customers
About Us
Imprint
Legal
Contact
Links
 

DocFlex/Together

  1. What is DocFlex/Together?
  2. Key Features
  3. Technical Requirements
  4. Advantages over old Together DocGen
  5. The Lite Edition

1.  What is DocFlex/Together?

DocFlex/Together is a revolutionary template-driven documentation generator for Borland® Together® 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 TogetherSoft Corp.), 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 started alone 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).
  • Provides advanced data querying and sorting capabilities comparable with those of XSL Transformations (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 output formats 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 template components can be specified in component properties using FlexQuery-expressions.

    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 DocFlex API).

    Within FlexQuery-expressions, it is possible to access the template parameters 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 detailed Class Documentation (similar to that produced by Javadoc), see screenshot
    • 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), see screenshot
    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 image scaling (this feature can be disabled).
  • 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:
  • Borland® Together® Architect version 1.x
  • Borland® Together® ControlCenter™ version 6.x or 5.x
  • Borland® Together® Solo version 6.x or 5.x
To run the Template Designer as separate application, you will need Java™ 2 JRE 1.4.x or JRE 1.3.x.

The DocFlex/Together Java libraries are supplied in two variants (both included in the packages available in downloads):

  1. The one optimized for JRE 1.4.x
  2. The another one compiled for JRE 1.3.x.
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).

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/Javadoc.

    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 (such as flow of text, paragraphs, tables and lists). 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 template parameters, 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 DocFlex templates 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:
    • 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 inspector dialog.
    • To extend your templates with the custom-written Java classes (called from within templates via 'callForName' function).
    The open DocFlex API will be fully documented shortly (with the release of version 1.1).

5.  The Lite Edition

“DocFlex/Together Lite” is a reduced version of DocFlex/Together without the Template Designer.

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 Borland® Together® 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).

Copyright© 2017 Filigris Works, Leonid Rudy Softwareprodukte. All rights reserved.