Packages and Modules Overview
The wxArt2D code is split in two packages, wxdocview and wxart2d. These packages each contain of several modules. The modules are organised as a hierarchy, with higher level modules depending on the lower level ones.
A module contains mainly files that form together a certain functionality. Modules do depend upon each other, and a certain hierarchy is in them. The hierarchy is not strict, sometimes in modules other modules are used but when wanted they can be switched on or off. Special attention is paid to be able to remove higher order modules, without problem. So the docview module can be used without the canvas module. But also lower order modules like xmlparse are optional for the docview module. Each module compiles and links to a library. Whereas, some of the modules require third party libraries, the basic wxArt2D modules require only the wxWidgets library.
- Packages and Modules Overview
- Package wxDocView
- Package wxArt2D
This is the base package. It can be used without the wxart2d package. It consists of three modules.
At the very bottom, the GeneralModule providing basic functionalities, e.g. smart pointers and properties. The optional XmlParseModule is needed for XML IO. The DocviewModule defines the document view framework.
The module general is used by all modules. It contains classes etc. that can be used in all other modules. a2dObject and its derived property classes are in this module. Another one is a2dSmrtPtr, which is a smart pointer template class. It works for classes with a Release and Own mechanism, which are all a2dObject derived classes. See GeneralModule for more.
This module contains the code for the Pullparser, it uses expat for parsing the xml for a file or string. XML Pull parsing is ideal for parsing XML data from a file, but where the reading of this data is distributed through all classes in other modules, and those classes are deciding what needs to be read from the file. This is different from a parser that reads all XML data at once into a DOM tree. Next to reading XML data, this module also support you to easily write XML data from a file, and again in such a manner that the writing of the data is distributed through all classes in other modules. The CVG format uses this module for saving a a2dCanvasDocument to a file and/or load it from a file. a2dIOHandlerXmlSerOut is the class used for that, and it is a general class for serializing class data.
The docview module contains the classes for the docview framework. It makes it easy to implement applications that open several documents, and display their data one or more windows using views. The canvas module and editor module depend on it. A base wrapping class for wrapping commands/ functions to external scripting languages is also in here. See DocviewModule for more.
This package requires the package wxdocview. Its many modules can be grouped in
- Drawer modules
- Canvas and editor modules
- IO modules
- Scripting modules
The ArtbaseModule is the base for drawing context classes, it depends only upon the GeneralModule. The ArtbaseModule has all definitions for styles like stroke, fill and fonts. AggDrawerModule and GdiPlusDrawerModule are derived.
This module contains basic geometric classes, and the abstract a2dDrawer2D class, classes derived from this are drawing context classes. The drawing context is able to draw relative to a matrix that is set to the drawing context first. The drawing contexts classes can be used standalone for wxWidgets, and that do not depend on the rest of wxArt2D. That is, it uses the general module, and the xmlparse module is used inside the style classes, but it can be switched off. There is one drawing context in this module which uses wxDc and wxMemoryDc to do normal drawing. The modules aggdrawer and gdiplusdrawer, use this module to implement a drawing context which can do antialiased drawing.
Drawing context for a2dCanvasDoucment, based on the AntiGrain rendering Library, http://www.antigrain.com/. With the current version (which is included with wxArt2D), one can already do anti-aliased rendering and editing.
This module defines drawing context classes for anti aliased double buffer drawing. It only depends on the general and artbase modules. The module is an implementation of the a2dDrawer2D class, and does not depend on the canvas module. So use for drawing, but in combination with the canvas module, can be used to render canvas documents.
Gdi+ (part of WinXP and newer) is used to do the actual drawing. This module defines drawing context classes for anti aliased double buffer drawing. It only depends on the general and artbase module. The module is an implementation of the wxDrawer2D class, and doesn't depend on the canvas module. So use for drawing, but in combination with the canvas module, can be used to render canvas documents.
Canvas and Editor Modules
The CanvasModule is on top of the DocviewModule and the ArtbaseModule. It is an extension to the document framework designed for containing drawings in documents. The CanExtObjModule is an extension on the CanvasModule, mainly for more advanced grahical objects and IO. The EditorModule extends the CanvasModule to add editing functionality to canvas document. It defines tools to interactively edit canvas objects. The CurveModule defines very advanced canvas objects, to display sets of curves and plots, which can be edited.
The CurveModule is on top of the CanvasModule, and so is CanExtObjModule. Both implement complicated non basic a2dCanvasObjects. Since the CurveModule has a tool inside, it also depend on the editor module. Very likely it is the best to combine higher order a2dCanvasObjects together with its tools to draw/ manipulate them. So therefore they will depend on the EditorModule in general.
The canvas module builds on top of the docview module a library for 2D drawing applications. A a2dCanvasDocument does contain a hierarchy of drawing objects (a2dCanvasOject), and the document can be displayed on windows, using specialized views called a2dCanvasView. a2dCanvasView internally uses the a2dDrawer2D derived classes to really draw the objects in the a2dCanvasDocument. Each view can display a different part and level of the hierarchy in the a2dCanvasDocument. The basic tools, a toolcontroller and a commandprocessor are also here. See CanvasModule for more.
This module defines canvas objects which are more advanced, and not used for any application. The idea is not to make the canvas module to big, and instead add extra fancy a2dCanvasObject derived objects here. Currently there are several object to make references on a canvas towards other canvas documents a2dCanvasDocumentReference. Like an overview of document which are open. Also those can be used to make documents which contain libraries of complex objects, a2dLibraryReference Also interesting is a2dCanvasDocumentIOHandlerImageIn, which allows you to save what is in a document to image files. You can define the size of the image, and automatically the document will be rendered into the image and saved into the format you choose.
The editor module is for editing 2d graphical data. Here are the tools, editor frame and a command processor to extend the canvas command processor for editing purposes. a2dEditorFrame is the spill together with a lot of dialog classes which are called from it, but not directly. Instead all is going via the a2dCentralEditorCommandProcessor. That way wxArt2D can record actions to a script. Most dialogs are more are less standalone, and work on the context and contenets of the current active view. See EditorModule for more.
Special objects for drawing multiple curves or bars etc. on a plot object. It can have markers attached to curves, and show-marker objects to display and edit the position of the markers on the curve.
This module gets the maximum from the wxArt2D library. It uses dependencies between curve objects and its marker object, in order to keep them in sync while editing the curve or marker. It also uses sub-editing, therefore in a plot of curves, one can edit each curve and the markers on the curve. First one starts editing the plot itself, but the plot object pushes other tools when clicking on the objects contained within the plot. Events in a2dCanvasObjects are organized such, that events travel through a hierarchy of nested a2dCanvasObjects. This makes the sub-editing of objects possible.
CVGIO, SVGIOModule, GDSIOModule and KeyIOModule are all implementing a specific way to save and load documents as defined in the CanvasModule. The modules svgio and gdsio are using the canvas module. But the canvas module can do without them, so this is the way to add extra IO formats. The classes parse a file and translate the contents to a a2dCanvasDocument containing the drawing in the form of a2dCanvasOjects. They can also write the a2dCanvasDocument back to a file, by traversing the document from the outside, and translating the contents of the document back to a the file format. The idea is to add more formats without extending the canvas module.
This is not a real module, but a built in option. It allows you to save a a2dCanvasDocument into a file and read it back. The format is XML based, and saves a hierarchical a2dCanvasDocument into a file. This format uses the wxWidgets dynamic class information, to store a class and its lower level children to a file, and later read them back. Based on the class name which is stored into the CVG format, the class can be reconstructed. The nice thing is that you can easily save your own canvas objects into the CVG format also. Two member functions to read and write the CVG format for a derived canvas object, is all that is needed. When another wxArt2D based program does not know the object you have written, it will skip it when reading it.
SVG IO Module
Basic Scalable Vector Graphics In and Output. Its understands all basic primitives in SVG and hierarchy, but the fancy stuff like animation etc. not. When reading SVG, it is translated/ mapped into a2dCanvasDocument.
When writing as SVG, all object stored into the a2dCanvasDocument are mapped to most advanced SVG drawing possible. A a2dCanvasDocument is meant for many drawing application, and not just for viewing SVG. The idea is that a2dCanvasObject derived complex objects can also be saved and loaded. But in case of saving as SVG, this will result in a simple drawing, and the original object can never be reconstructed. For that we have the CVG format.
GdsII format In and Output. This is a Computer Aided Design format for the chip industry. It is layers based, and contains hierarchy in so called structures. Structures are like sub-drawings, which can be referenced at any position on a higher level. This a key feature in wxArt2D, it knows how to deal with multiple references to one drawing. Automatic updating, and bounding box calculation is all based on this principle. Not many canvas libraries can do this.
KeyIO format In and Output. Which is an ascii readable representation of GDSII, plus extra objects like circles. Also the object can have properties added to them. See also GDSIO Module.
On top of all this is theLuaWrapsModule, which implements scripting based on wxLua using wxArt2D's functionality.
This module uses all other modules and wraps its functionality into wxLua bindings. That way you can write programs in wxLua that are using wxArt2D. But more often you will like to use the scripting to automate things in your own C++ application. This all becomes easy with this module, you can also easily extend the bindings with your own application functionality. A typical use is to startup your application by reading a configuration file written in lua. This gives the user of your application an enormous amount of flexibility. WxArt2D does even have objects which can be placed in a canvas document, but which are drawn/created using a lua script. For more see LuaWraps.