Packages and Modules Overview

The wxArt2D code is split in two packages, wxdocview and wxart2d. These packages each containing several modules. The modules are organized as a hierarchy, with higher level modules depending on the lower level ones. For the whole framework, wxart2d depends on wxdocview, to have applications with multiple drawing, organized as documents, containing those drawings. It is also possible to build the wxart2d, without using the wxdocview framework. That will gives you mainly a canvas with drawing inside, and tools to work on the drawing.

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 requires only the wxWidgets library.

Package wxDocView

This is the base package. It can be used without the wxart2d package. It consists of three modules.

Modules

At the very bottom, the GeneralModule providing basic functionalities, e.g. smart pointers and properties and event handling. The optional XmlParseModule is needed for XML IO. The DocviewModule defines the document view framework.

General Module

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.

XmlParse Module

This module contains the code for the Pullparser, it uses expat for parsing the xml from a file or string. XML Pull parsing is ideal for parsing XML data from a file, especially 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 supports classes to easily write XML data to 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.

Docview Module

The docview module contains the classes for the docview framework. It makes it easy to implement applications that open several documents, and display the data in the documents in one or more windows using views. The editor module depends on it. See DocviewModule for more.

Package wxArt2D

This package requires the package wxdocview. Its many modules can be grouped in

• Drawer modules
• Canvas and editor modules
• IO modules
• Scripting modules

Drawer 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 use those classes for implementation of extra drawing context classes.

ArtBase Module

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 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 wxWidgets like drawing. The modules aggdrawer and gdiplusdrawer, use this module to implement a drawing context which can do antialiased drawing.

AggDrawer Module

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 used for drawing only, but in combination with the canvas module, can be used to render a2dCanvas its a2dDrawing.

GdiPlusDrawer Module

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 GeneralModule and the ArtbaseModule. The EditorModule 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 graphical objects and IO. The CanvasModule also adds editing functionality to canvas drawing. 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. It is the best to combine higher order a2dCanvasObjects together with its tools to draw/ manipulate them.

Canvas Module

The canvas module builds on top of the general module and th ArtbaseModule, creating a library for 2D drawing applications. A a2dDrawing does contain a hierarchy of drawing objects a2dCanvasObject, which can be displayed on a a2dCanvas. The a2dCanvas uses internally a a2dDrawingPart, which on its turn uses a2dDrawer2D as drawing context to do the actual drawing of the objects in the a2dDrawing. One can inject a a2dToolController into a a2dDrawingPart, which gives you a large set of interactive drawing tools, to edit the drawing that is displayed on the canvas window. Those tools issue commands to the a2dCanvasCommandProcessor, and that make the editing undo-able.

See CanvasModule for more.

CanExtObj Module

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.

Editor Module

The editor module extends the basic DocviewModule, to contain a2dCanvasDocuments. And since a a2dCanvasDocument can contain several a2dDrawing's, the CanvasModule is used to edit those drawing again. A specialized editor frame and a command processor do extend the canvas command processor for working with multiple documents. 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 contents of the current active view. See EditorModule for more.

Curve Module

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.

IO Modules

CVGIO, SVGIOModule, GDSIOModule and KeyIOModule are all implementing a specific way to save and load documents as defined in the EditorModule. The modules svgio and gdsio are using the editor module. But the editor 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.

CVG IO

This is not a real module, but a built in option. It allows you to save a a2dCanvasDocument and/or a2dDrawing 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 objects 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.

GDSIO Module

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 Module

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.

Scripting

On top of all this is the LuaWrapsModule, which implements scripting based on wxLua using wxArt2D's functionality.

LuaWraps Module

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.

• CategoryModules