Home | Back
ADG 0.7.6

Page margins and paddings are now managed consistently across
the different surfaces and their behavior has been documented.

The NSIS script for generating the Windows installers has been
subject to many improvements: it can now optionally install
ADG and CPML manuals (either in HTML and in PDF format) and the
localization data (only italian for now). It should also handle
the application icons properly.

The adg_canvas_export() function can save a canvas to a file in
one command. It needs a patched gobject-introspection though: see
bug #743364 (https://bugzilla.gnome.org/show_bug.cgi?id=743364).

The localization infrastructure has been improved up to the point
gettextize and intltool are no more required.

ADG 0.7.5

The algorithm to use for offsetting Bézier curves is now selectable by
calling the non-reentrant cpml_curve_offset_algorithm() function.

A new offsetting algorithm (BAIOCA) has been implemented. It tries to
minimize the error between the offset curve and the ideal offset point
on evenly spaced t values.

The source code has been revamped to minimize the warnings raised by new
versions of gcc, gtk-doc and gobject-introspection.

The internal sources have been refactored to manage GTK+2 and GTK+3
differences with the same codebase.

ADG 0.7.4

Improved documentation: the API reference manual is now kept in
sync with the online documentation (http://adg.entidi.com/) by
using a dedicated SilverStripe module (http://gtkdoc.entidi.com/).
This really simplifies the maintenance burden of the doc.

A bug that was preventing the correct finalization of the returned
cairo path from GObject introspection bindings has been corrected.

ADG 0.7.3

The compatibility of the project with outdated systems has been
improved in order to be able to install it on old web servers.

Compilation without GTK+ support has been tested: the canvas is now
properly working on a server without X server installed.

ADG 0.7.2

Out of the box bindings are now fully working: the adg-demo
program provided by adg-lua (http://adg.entidi.com/home/bindings/) is
in par with the official adg-demo in C.

AdgDress is inherited from GEnum instead of being a handcrafted
solution. A lot of specialized code have been removed, so the
mapping between numbers and names in bindings is automatic.

Consistency in widget names has been improved, allowing to
simplify signal connections on the Lua side.

ADG 0.7.1

Out of the box support for LGI (http://github.com/pavouk/lgi/)
(dynamic Lua bindings based on GObject introspection) is now
provided upstream and effectively used for testing APIs. The
introspection support has been improved, some APIs (AdgPoint
related methods above all) have been protected against NULL and
some bugs raised by the bindings work have been corrected.

The GBoxed wrappers for cairo structs such as cairo_matrix_t have
been dropped in favor of the native support provided by the
cairo-gobject library.

GObject wrappers for CPML structs such as pairs, primitives and
segments has been moved to CPML itself. This makes redundant the
presence of wrappers on the ADG side, simplyfing the work for the
language bindings.

ADG 0.7.0

The autoscaling feature is now available: a series of predefined
scale factors are applied until the proper one is found. The demo
program autoscales the drawing on a right click on the drawing
area and restores the paper zoom and position on a left click.

The introspection support has been improved, making it possible
to have LGI (Lua) bindings working out of the box. The typedef
hack has been dropped in favor of a private forwarder header.

The dash pattern of AdgLineStyle can now be customized by binding
to it an AdgDash instance.

ADG 0.6.6

The project has been ported to GTK+3 also on Windows platforms.
The helper scripts now build only GTK+3 installers.

The recent porting of Fedora mingw packages to archlinux made
possible to generate for the first time a win64 installer.

adg-demo now embeds icons of different sizes, ranging from 16x16
to 128x128 pixels. The look-up falls back to srcdir so the icons
can be used also without installing the program. A bunch of new
APIs has been added to help this relocation.

The Windows installers received a lot of cosmetic improvements.
The NSIS code has been cleaned up.

ADG 0.6.5

Some missing documentation files that prevented the proper build
adg-0.6.4 have been included in the distribution package.

ADG 0.6.4

The Lua bindings, based on lgob, are now available as a separate
project (adg-lua). The glue code is automatically generated
using GObject introspection.

The build system can detect and use GTK+3 and gladeui-2.0 when
found. GTK+2 and gladeui-1.0 are still availables and can be forced
at configure time.

The rendering of AdgRDim has been enhanced: when the "outside"
property is enabled, the leader line will extend beyoud the arc to
quote for a styleable distance, and the marker will be reveresed.

The best text frontend is selected at configure time. When pango
is available, it will be preferred over the cairo toy text APIs.

ADG 0.6.3

The text manipulation logic has been moved inside the AdgTextual
interface and a new entity based on pango (AdgText) has been added.
Also AdgToyText implements AdgTextual so all the text entities are
now interchangeable.

The demo program has a new dialog page that allows to customize
the title block of the drawing. The zoom hints have been moved
outside the paper so the drawing can be considered finalized.

The CPML library has its own test framework. Anyway tests have
been improved generally so it is now possible to generate a
report by using "make test-report".

The missing extents computation on AdgRDim, AdgADim and AdgArrow
are now in place. By calling adg-demo with the -E option it
is possible to visually verify the extents status.

A bunch of bugs, most notably the wrong glade catalogdir detection
and some extents computation, have been resolved.

ADG 0.6.2

The localization infrastructure has been added and tested by adding
the italian translation.

The AdgGtkArea widget is now capable of interactively change zoom
and pan in global space by dragging and/or rotating the wheel while
keeping the shift pressed.

A new class has been implemented: AdgGtkLayout is an AdgGtkArea
based widget that implements the scrolling natively, hence it can
be added directly to a GtkScrolledWindow container.

ADG 0.6.1

The canvas now has printing support when compiled with GTK+ enabled.
The media setup can be associated to the canvas so this data can be
accessed to provide a consistent behavior between different backends.

The demo program can now render the drawing to an SVG file.
Generated files are stored in the user document directory.

Uncomplete entities now fail gracefully instead of complaining for
insufficient data. This provides an easy way to implement optional
machinings: the optional groove in the adg-demo program is working
by leveraging this feature.

ADG 0.6.0

The portability of the build system has been improved: the ADG project
now builds out of the box on FreeBSD, OpenSolaris, MinGW32 and GNU/Linux.

The adg-demo program has been rewritten almost from scratch to provide
a nice example of what the ADG should be used for. The rendering has
been cleaned up and the model-view interaction now works: changing the
data on the edit dialog changes the drawing (this is what the ADG has
been developed for). The GTK+ widget, although not shining, is fairly
usable and light years ahead of the previous version.

The canvas now has custom paddings and margins, a background dress and
the ability to accept an AdgTitleBlock entity.

The project tree has been rearranged in three different subprojects:
CPML (mathematical stuff above cairo), ADG (the canvas above CPML) and
ADG-GTK (user interface helpers above ADG and GTK+).

Support for glade-3 has been added: if enabled, ADG-GTK will try to
install its catalog in the proper glade directory.

ADG 0.5.6

The build system has done a huge step toward portability: the
requirements are less restrictive and the overall implementation
is cleaner and well defined.

The API has been exercised by API-Sanity-Autotest that helped to
discover some problems: check out issue #23 for details.

A test framework based on glib-2.16 has been added. It is still
under development but yet fully working.

The CPML API has been cleaned up by using an internal struct of
function pointers to delegate the job to the different primitives.
The public symbols of the CPML library have been reduced from 105
to 70.

ADG 0.5.5

The quote of linear dimensions can be freely positioned using the
AdgDim:pos property. By default, ADG keeps the quote inside the
extension lines if there is enough room, otherwise displaces it
to the "pos" coordinates.

A document describing how to contribute to the project has been
added. A general description of the API conventions used by is
also provided.

A lot of bug fixing and code clean up. A bug in the installation
has been solved and support for pkg-config has been added. This
will probably be the last release of the 0.5 branch.

ADG 0.5.4

AdgTable now provides a generic tabular entity customizable with
AdgTableStyle. It supports unlimited rows with independent cells.

Some new special entities, such as AdgLogo (the official ADG logo)
and AdgProjection (showing the drawing projection scheme) have
been implemented.

A bare title block entity, AdgTitleBlock, is now available: it is
allowed to set its cells content either by using string values or
custom entities.

AdgAlignment is a new container entity that allows to traslate its
children of a custom factor of the children boundary box: any
entity can now be right aligned or centered.

ADG 0.5.3

AdgRDim, a new entity to quote radial dimensions, is now available.

A bunch of new classes to manage hatches have been implemented.
Specifically, AdgHatch is the entity to be added to the canvas,
AdgFillStyle a generic abstract class that wraps cairo_pattern_t
and AdgRuledFill the AdgFillStyle implementation to fill an hatch
with a serie of parallel lines with custom spacing and angle.

The AdgModel now supports named pairs, that is any coordinates
can be set explicitely (as before) or as a reference to a pair
set by the model. The AdgPoint helper class is the object used
to manage this relationship. The API of dimension entities has
been updated to accept AdgPoint instead of plain AdgPair.

ADG 0.5.2

AdgADim, a new entity to quote angular dimensions, is implemented.

The linear dimensions now accept the "outside" property to reflect
the arrows around the extension lines. The default value of this
property is ADG_THREE_STATE_UNKNOWN, meaning it will be computed at
runtime, depending on quote size and available space.

The new AdgEdges model can now be used to programmatically build a
serie of vertical lines expressing the edges of another model. This
can be used on symmetrical shapes, often met in turned parts.

The entities now actively respond to extents requests: it is possible
to know the necessary space before rendering them. Any matrix change
now emits specific signals to fulfill this requirement.

ADG 0.5.1

The new AdgMarker abstract class has been added to provide a common
ancestor to marker entities. AdgArrow (a filled arrow) is its first
renderable implementation.

The rendering customization is now provided by AdgDress, an index that
virtualizes the underlying AdgStyle and derived instances. This allows
some advanced operation, such as overriding a style in a specific branch
of the entity hierarchy. The deprecated AdgContext class has been removed.

The AdgPath class has been splitted in AdgTrail and AdgPath. The former
provides low level access to CpmlPath, allowing the implementation of
paths that do not fit in the global/local model. AdgLDim internally
uses a private AdgTrail to implement base and extension lines rendering.

ADG 0.5.0

The old paper-model matrix approach has been superseded by a cleaner and
smarter approach based on global/local maps. This resulted in a great
code complexity reduction: check out the home page for further details.

Parent-child relationship is no more tied to AdgContainer: dependencies
between AdgEntities can now be expressed without a full-fledged container.

AdgDim now uses internally four AdgToyText entities to render the quote.
This has been made possible by the new parent-child APIs, simplyfing the
rendering code a lot.

A bunch of classes, most notably AdgRotable, AdgTranslatable and AdgPoint,
have been superseded by the new global/local map approach and have been
removed from the project.

ADG 0.4.3

Higher level operators, such as chamfer and fillet, can now be used
in the path definition. They do not work yet for Bézier curves but
the infrastructure is in place.

A Gtk+ widget for easily showing the canvas has been implemented. It
is based on GtkDrawingArea and provides some interaction throught the
mouse, such as zooming and panning. It is not viable for serious work
but it is funny to use and opened to improvements.

The CPML library has been enriched with the missing functions
needed by the above new features. Now it has a ..._length() and
..._near_pos() families of functions. The mathematic behind this
library is far from complete: the overall design is quite stable
but there are a lot of placeholders, especially when curves were

ADG 0.4.2

The work on model-view separation has been started: the AdgModel
abstract class is now in place. Above this class, the new AdgPath
model is derived, providing a full set of APIs to construct paths
from scratch. Also, AdgPath gives full access the model throught
CPML, allowing to modify and manipulate the path data.

The CPML library now natively supports arcs. Although cairo does
not recognize arcs, a lot of work has been done to hide the
complexity needed to provide an API that does the necessary
trasformations transparently.

The old AdgPath entity has been rewrote to AdgStroke. This is a
stroked view of an AdgPath model. Its implementation is trivial
as all the path complexity has moved to AdgPath.

ADG 0.4.1

The CPML library has been boosted with additional APIs to browse
segments/primitives and to compute intersections between different
constructs. Now it has its own demo program (cpml-demo), showing
some of the implemented feature. Although some function is still
a stub, the overall infrastructure is likely to be definitive.

All the CPML APIs are now properly documented.

The ldim demo has been merged into the more complex adg-demo.
Now the demo programs use the GtkBuilder feature, so the Gtk+
dependency has been raised to 2.12.

ADG 0.4.0

The useless wrappers in AdgPath have been removed: now the standard
cairo path API could be used in the path constructor callback.

AdgPoint has been added. This new core struct can be used to represent
a coordinate system with different model and space component.

The new AdgToyText entity can be used to show arbitrary text using the
cairo "toy" text API.

Two interfaces, AdgTranslatable and AdgRotable, have been implemented
to allow arbitrary positioning (using the new AdgPoint struct) and
rotation of entities where this is applicable (e.g. AdgToyText).

The CPML API has been almost rewrote from scratch: removed a lot of
duplicated stuff, dropped CpmlPath (by using the original cairo_path_t)
and implemented new functions, such as segment browsing (always in
forward direction), reversing and transformation.

README, NEWS, TODO and ChangeLog are now automatically generated, so
redundancy is removed and the maintainability improved. The originals
are kept in docbook format, allowing to use them also in html version.

The adg-demo program now allows to save the sample drawing in png, pdf
and postscript. Two useless toy text entities has been added.

ADG 0.3.2

The dependency on libgcontainer has been dropped: now the adg canvas
requires only cairo and Gtk+2 (will be optional). This allows to try
the demo program (demo/adg-demo) on any decent GNU/Linux distribution
without installing anything.

The container logic has been included in AdgEntity (the GChildable
portion) and AdgContainer (the GContainerable part).

ADG 0.3.1

Implemented the "invalidate" signal to force the cache recomputation
on a new rendering operation.

The new cairo "toy" API has been used to do text management in AdgDim.
This allows caching of the intermediate glyphs for improved
performances (no profiling yet done). The cairo dependency has been
raised to version 0.7.4 or more.

The AdgLDim entity has been rewritten to full implement the new cache
design. Other entities have been improved to allow a paper matrix
other than the default identity matrix.

ADG 0.3.0

Reworked styles and implemented AdgContext, a clean and well defined
approach to manage rendering customization.

Moved all the geometrical stuff in Cairo Path Manipulation Library
(CPML), an internal library depending only on cairo.

Greatly improved documentation.

ADG 0.2.2

Strongly separated model and paper matrix concepts and updated their
management using nested transformations.

Reworked the rendering process in a cleaner way by propagating the
"render" signal and using internal entity states to let the application
know what changed from the previous rendering.

ADG 0.2.1

Reworked the sources tree in a cleaner way (to help future development)
and used private structs instead of populating the instance structure.

ADG 0.2.0

This is the first public release of the ADG library. It is in a early
stage of developement, but the goal is quite ambitious!