Free vtoc diagram software for linux

Ghost Diagrams is a project that takes sets of tiles and tries to find patterns into which they may be formed. The patterns it finds when given randomly chosen tiles are often surprising.

It turns out that tiling patterns are a form of computation of equal power to Turing machines, lambda calculus, and cellular automata. For example, here is a tileset implementing "Rule 110", a cellular automaton known to be capable of universal computation.

Considerations similar to the halting problem and Godels theorem apply. There is no upper limit to their capacity to surprise us. Furthermore, tiles have an intuitive quality that other forms of computation lack. You can see how they fit together.

An organism is more than the sum of its organs. When the organs are fitted together, the organism becomes something more. This surprising something more we call "spirit" or "ghost". Ghost Diagrams finds the ghosts implicit in simple sets of tiles.

Clara is a help-documentation tool for C++ or java developers. Basically she paints a diagram - a clara diagram - from a class.

With clara you can visualize your class as if it were a chip with pins for input - representing the input parameters of the methods - and pins for output - representing the return type of the functions-.

Lets see for example the diagram that clara would draw for the following C++ sample class

class sampleInterface
{
public:

void init (MyStructure * pstruct);

void setPoint (float x, float y);

float getX ();
float getY ();

void processIt ();
};

What are these pins for ? Are we going to connect them somehow ? Not at all, it is just a convenient way to represent what the class offers in a very compact form.

Of course the diagram will be drawn by clara automatically, there is no need (and no chance) of manually drawing anything.

Clara gets the needed information in two ways : using reflection in java and parsing the header file in C++. Clara can also draw a call-diagram of the class if the sources are found, note though that for the call-diagram an extra tool is needed (dot.exe from http://www.graphviz.org) and it has to be installed apart.

dia2fsm reads DIA diagram files constructed in the prescribed format and produces Finite State Machine (FSM) skeleton code. This project supports code generation to C and C++ and is built on Linux only.

Additionally, if an output PNG file is specified with the -o option, an additional output file suitable for use as input to the AT&T Graphviz application DOT is also generated. When this DOT output file is specified, DOT will be spawned and the DOT configuration file used to generate a graphical representation of the call hierarchy in the FSM and related push-down automata.

Additional features include the facility to describe transitions from state to state in such a way that it becomes possible to generate member functions and associated logical flow and control so as to implement directly and explicitly the logic described by the FSM in the output skeleton code. It is intended that
extensions to the software providing further code generation options follow this model.

dia2fsm is constrained by the nature of the XML generated by DIA; it is necessary to observe certain conventions when using DIA and dia2fsm. It is hoped that these conventions do not require a significant or unsurmountable philosophical paradigm shift.

This first (reference) version of the software is implemented in C++, on Windows 2000 Professional with the

MinGW tool-set via Eclipse V 3.1.0. The software uses Trolltechs Qt toolkit for platform dependent operations such as file I/O, process control and for XML handling.

The reference version of the software supports code generation in C and C++ only; it is expected that a Java implementation at least will follow quickly.

HTML::Toc module can generate, insert and update HTML Table of Contents.

The HTML::Toc consists out of the following packages:

HTML::Toc
HTML::TocGenerator
HTML::TocInsertor
HTML::TocUpdator

HTML::Toc is the object which will eventually hold the Table of Contents. HTML::TocGenerator does the actual generation of the ToC. HTML::TocInsertor handles the insertion of the ToC in the source. HTML::TocUpdator takes care of updating previously inserted ToCs.

HTML::Parser is the base object of HTML::TocGenerator, HTML::TocInsertor and HTML::TocUpdator. Each of these objects uses its predecessor as its ancestor, as shown in the UML diagram underneath:

+---------------------+
| HTML::Parser |
+---------------------+
+---------------------+
| +parse() |
| +parse_file() |
+----------+----------+
/_
|
+----------+----------+ +-----------+
| HTML::TocGenerator + - - - - - -+ HTML::Toc |
+---------------------+ +-----------+
+---------------------+ +-----------+
| +extend() | | +clear() |
| +extendFromFile() | | +format() |
| +generate() | +-----+-----+
| +generateFromFile() | :
+----------+----------+ :
/_ :
| :
+----------+----------+ :
| HTML::TocInsertor + - - - - - - - - -+
+---------------------+ :
+---------------------+ :
| +insert() | :
| +insertIntoFile() | :
+----------+----------+ :
/_ :
| :
+----------+----------+ :
| HTML::TocUpdator + - - - - - - - - -+
+---------------------+
+---------------------+
| +insert() |
| +insertIntoFile() |
| +update() |
| +updateFile() |
+---------------------+

When generating a ToC youll have to decide which object you want to use:

TocGenerator:

for generating a ToC without inserting the ToC into the source

TocInsertor:

for generating a ToC and inserting the ToC into the source

TocUpdator:

for generating and inserting a ToC, removing any previously inserted ToC elements

Thus in tabular view, each object is capable of:

generating inserting updating
---------------------------------
TocGenerator X
TocInsertor X X
TocUpdator X X X

Dia is designed to be much like the commercial Windows program Visio. It can be used to draw many different kinds of diagrams.

Dia project currently has special objects to help draw entity relationship diagrams, UML diagrams, network diagrams, flowcharts, and simple circuits. It is also possible to add support for new shapes by writing simple XML files, using a subset of SVG to draw the shape.

It can load and save diagrams to a custom XML format (gzipped by default, to save space), can export diagrams to EPS or SVG formats and can print diagrams (including ones that span multiple pages).

OFBiz Neogia is an ERP solution based on the OFBiz framework.

The free software and open source ERP solution OFBiz Neogia leans on OFBiz ERP sturdy technical foundations (project launched since 2001), a set of technical and business components well known for their high coverage, flexibility and great sturdy.

OFBiz Neogia is a integrated business solution specifically conceived to answer to business needs of rapidly expanding SMEs. OFBiz Neogia solution covers finance, supply chain management (including production management and distribution), CRM (including marketing, sales, after-sales and service management) as well as e-commerce.

Available on every J2EE solutions and every SGDB, OFBiz Neogia runs under Microsoft Windows and under every Unixes supporting Java including Linux.

OFBiz Neogia adpats itself to your growth and to evolutions of your activity by letting you fire the best part of your time and of your resources. You can now rationalise your activity and increase your activity.

Neogia comes as a set of add-on component for OFBiz the enteprise application framework. Neogia is a complete ERP solution. Neogia doesnt aim to replace the OFBiz framework. It needs a full OFBiz installation to work except for the code generators. Neogia provides 3 types of component :

Functional componant (or business component). These components can be are integrated in OFBiz as new components or replacing an existing OFBiz component (or sub-component).
- manufacturing : replace the OFBiz existing component, Its a complete refactorization of it, a UML class diagram dedicated and a complete new coding.
- facility : replace the stock management OFBiz component, picking and shipment management are not included in neogia, we continu to use the OFbiz sub-components. Neogia-Facility inclue a full Physical Inventory component. This component has been build after a refactorization of the data modele with the UML modelization to be able to manage Stock Event releazed and planned.
- accounting : replace the OFBiz existing sub-componentl, for General ledger and controling entries. UML class diagram est new. Payement management continu to be manage by ofbiz.
- servicemgnt : new component to manage all service activities or project activities. UML class diagram est new.

add-on to existing Ofbiz Component for Neogia components access. The associated UML class diagram describe the OFBiz entity and their association with the Neogia component.
- common : used to manage all the enumeration and status neogia attribue, (technically managed in the OFBiz entity Enum and Status)
- content : used to unified development rules et manage the multi-language String Neogia attribue.
- order : used to access order header and item.
- party : used to access Party, RoleType, PartyRole and Communication entities.
- product : used to acess Product and for managing integration between OFBiz ad Neogia-Facility.

A technical component, used to generate most of the OFBiz files from UML class diagram. With generation you can have a better object approach because one object is available for each entity, you can generalized the OFBiz best practice because all the generated file use its.

All file developed are realized as extend of the generated file so its possible to regenerate the file when a new technology or best practice appair.

dia2sql is yet another dia2sql converter. It uses libxml2 to parse UML objects from a Dia diagram and generates corresponding SQL code to create the tables specified in the UML diagram
It takes one or more filenames and outputs to stdout. Multiple files are considered as one database by merging multiple tables with the same name.
Enhancements:
- This release has been rewritten in C and adds support for database views.

UMLGraph facilitates the declarative specification and drawing of UML class and sequence diagrams.
One can specify a class design using the Java syntax complemented by Javadoc tags.
Running the UmlGraph doclet on the specification generates a Graphviz diagram specification that can be automatically processed to create Postscript, GIF, SVG, JPEG, fig, or Framemaker drawings.
Similarly, sequence diagrams are specified using declarative pic macros and compiled with the GNU plotutils pic2plot program into a PNG, PNM, (pseudo) GIF, SVG, AI, Postscript, CGM, FIG, PCL, HPGL, Regis, or TEK drawing.
Enhancements:
- This version improves its invocation interface so that it can be run directly as a jar file.
- It has support for sending results to the standard output for direct piping into dot.
- The distribution includes an example shell script and batch file for invoking UMLGraph.