Initial revision

git-svn-id: svn://localhost/trunk/ardour2@4 d708f5d6-7413-0410-9779-e7cbd77b26cf

66 files changed, 12702 insertions, 0 deletions

diff --git a/libs/libgnomecanvasmm/.DS_Store b/libs/libgnomecanvasmm/.DS_Store
new file mode 100644
index 0000000000..7fc822ba63
--- /dev/null
+++ b/libs/libgnomecanvasmm/.DS_Store
diff --git a/libs/libgnomecanvasmm/AUTHORS b/libs/libgnomecanvasmm/AUTHORS
new file mode 100644
index 0000000000..da913ffe29
--- /dev/null
+++ b/libs/libgnomecanvasmm/AUTHORS
@@ -0,0 +1,40 @@
+Maintainers:
+Murray Cumming <murrayc@usa.net>
+
+Developers:
+Paul Davis <pdb@op.net>
+Gergo Erdi <cactus@cactus.rulez.org>
+
+
+gnomemm 1.2:
+
+Developers:
+Claudio Bley
+Eric Bourque
+Manuel Clos <llanero@users.sourceforge.net>
+Daniel Elstner <daniel.elstner@gmx.de>
+Gergõ Érdi <cactus@cactus.rulez.org>
+Cedric Gustin
+Andreas Holzmann
+Falk Hueffner
+Peter Lerner <plerner@users.sourceforge.net>
+Agustin Ferrin Pozuelo
+Karl Nelson <kenelson@users.sourceforge.net>
+Herbert Valerio Riedel <hvr@gnu.org>
+Sebastian Rittau<srittau@users.sourceforge.net >
+Joe Yandle
+
+
+Former contributors:
+
+Tero Pulkkinen <terop@modeemi.cs.tut.fi>
+Stephan Kulow <coolo@itm.mu-luebeck.de>
+Elliot Lee <sopwith@redhat.com>
+Phil Dawes <P.L.Dawes-CSSE94@cs.bham.ac.uk>
+Erik Andersen <andersee@debian.org>
+Bibek Sahu <scorpio@dodds.net>
+Mirko Streckenbach
+Havoc Pennington <hp@redhat.com>
+Guillaume Laurent <glaurent@telegraph-road.org>
+Todd Dukes <tdukes@ibmoto.com>
+
diff --git a/libs/libgnomecanvasmm/COPYING b/libs/libgnomecanvasmm/COPYING
new file mode 100644
index 0000000000..c4792dd27a
--- /dev/null
+++ b/libs/libgnomecanvasmm/COPYING
@@ -0,0 +1,515 @@
+
+                  GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 2.1, February 1999
+
+ Copyright (C) 1991, 1999 Free Software Foundation, Inc.
+     59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the Lesser GPL.  It also counts
+ as the successor of the GNU Library Public License, version 2, hence
+ the version number 2.1.]
+
+                            Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+  This license, the Lesser General Public License, applies to some
+specially designated software packages--typically libraries--of the
+Free Software Foundation and other authors who decide to use it.  You
+can use it too, but we suggest you first think carefully about whether
+this license or the ordinary General Public License is the better
+strategy to use in any particular case, based on the explanations
+below.
+
+  When we speak of free software, we are referring to freedom of use,
+not price.  Our General Public Licenses are designed to make sure that
+you have the freedom to distribute copies of free software (and charge
+for this service if you wish); that you receive source code or can get
+it if you want it; that you can change the software and use pieces of
+it in new free programs; and that you are informed that you can do
+these things.
+
+  To protect your rights, we need to make restrictions that forbid
+distributors to deny you these rights or to ask you to surrender these
+rights.  These restrictions translate to certain responsibilities for
+you if you distribute copies of the library or if you modify it.
+
+  For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you.  You must make sure that they, too, receive or can get the source
+code.  If you link other code with the library, you must provide
+complete object files to the recipients, so that they can relink them
+with the library after making changes to the library and recompiling
+it.  And you must show them these terms so they know their rights.
+
+  We protect your rights with a two-step method: (1) we copyright the
+library, and (2) we offer you this license, which gives you legal
+permission to copy, distribute and/or modify the library.
+
+  To protect each distributor, we want to make it very clear that
+there is no warranty for the free library.  Also, if the library is
+modified by someone else and passed on, the recipients should know
+that what they have is not the original version, so that the original
+author's reputation will not be affected by problems that might be
+introduced by others.
+^L
+  Finally, software patents pose a constant threat to the existence of
+any free program.  We wish to make sure that a company cannot
+effectively restrict the users of a free program by obtaining a
+restrictive license from a patent holder.  Therefore, we insist that
+any patent license obtained for a version of the library must be
+consistent with the full freedom of use specified in this license.
+
+  Most GNU software, including some libraries, is covered by the
+ordinary GNU General Public License.  This license, the GNU Lesser
+General Public License, applies to certain designated libraries, and
+is quite different from the ordinary General Public License.  We use
+this license for certain libraries in order to permit linking those
+libraries into non-free programs.
+
+  When a program is linked with a library, whether statically or using
+a shared library, the combination of the two is legally speaking a
+combined work, a derivative of the original library.  The ordinary
+General Public License therefore permits such linking only if the
+entire combination fits its criteria of freedom.  The Lesser General
+Public License permits more lax criteria for linking other code with
+the library.
+
+  We call this license the "Lesser" General Public License because it
+does Less to protect the user's freedom than the ordinary General
+Public License.  It also provides other free software developers Less
+of an advantage over competing non-free programs.  These disadvantages
+are the reason we use the ordinary General Public License for many
+libraries.  However, the Lesser license provides advantages in certain
+special circumstances.
+
+  For example, on rare occasions, there may be a special need to
+encourage the widest possible use of a certain library, so that it
+becomes
+a de-facto standard.  To achieve this, non-free programs must be
+allowed to use the library.  A more frequent case is that a free
+library does the same job as widely used non-free libraries.  In this
+case, there is little to gain by limiting the free library to free
+software only, so we use the Lesser General Public License.
+
+  In other cases, permission to use a particular library in non-free
+programs enables a greater number of people to use a large body of
+free software.  For example, permission to use the GNU C Library in
+non-free programs enables many more people to use the whole GNU
+operating system, as well as its variant, the GNU/Linux operating
+system.
+
+  Although the Lesser General Public License is Less protective of the
+users' freedom, it does ensure that the user of a program that is
+linked with the Library has the freedom and the wherewithal to run
+that program using a modified version of the Library.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.  Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library".  The
+former contains code derived from the library, whereas the latter must
+be combined with the library in order to run.
+^L
+                  GNU LESSER GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License Agreement applies to any software library or other
+program which contains a notice placed by the copyright holder or
+other authorized party saying it may be distributed under the terms of
+this Lesser General Public License (also called "this License").
+Each licensee is addressed as "you".
+
+  A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+  The "Library", below, refers to any such software library or work
+which has been distributed under these terms.  A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language.  (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+  "Source code" for a work means the preferred form of the work for
+making modifications to it.  For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control
+compilation
+and installation of the library.
+
+  Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it).  Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+
+  1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+  You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+
+  2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) The modified work must itself be a software library.
+
+    b) You must cause the files modified to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    c) You must cause the whole of the work to be licensed at no
+    charge to all third parties under the terms of this License.
+
+    d) If a facility in the modified Library refers to a function or a
+    table of data to be supplied by an application program that uses
+    the facility, other than as an argument passed when the facility
+    is invoked, then you must make a good faith effort to ensure that,
+    in the event an application does not supply such function or
+    table, the facility still operates, and performs whatever part of
+    its purpose remains meaningful.
+
+    (For example, a function in a library to compute square roots has
+    a purpose that is entirely well-defined independent of the
+    application.  Therefore, Subsection 2d requires that any
+    application-supplied function or table used by this function must
+    be optional: if the application does not supply it, the square
+    root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library.  To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License.  (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.)  Do not make any other change in
+these notices.
+^L
+  Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+  This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+  4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machine-readable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+  If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library".  Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+  However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library".  The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+  When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library.  The
+threshold for this to be true is not precisely defined by law.
+
+  If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work.  (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+  Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+^L
+  6. As an exception to the Sections above, you may also combine or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+  You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License.  You must supply a copy of this License.  If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License.  Also, you must do one
+of these things:
+
+    a) Accompany the work with the complete corresponding
+    machine-readable source code for the Library including whatever
+    changes were used in the work (which must be distributed under
+    Sections 1 and 2 above); and, if the work is an executable linked
+    with the Library, with the complete machine-readable "work that
+    uses the Library", as object code and/or source code, so that the
+    user can modify the Library and then relink to produce a modified
+    executable containing the modified Library.  (It is understood
+    that the user who changes the contents of definitions files in the
+    Library will not necessarily be able to recompile the application
+    to use the modified definitions.)
+
+    b) Use a suitable shared library mechanism for linking with the
+    Library.  A suitable mechanism is one that (1) uses at run time a
+    copy of the library already present on the user's computer system,
+    rather than copying library functions into the executable, and (2)
+    will operate properly with a modified version of the library, if
+    the user installs one, as long as the modified version is
+    interface-compatible with the version that the work was made with.
+
+    c) Accompany the work with a written offer, valid for at
+    least three years, to give the same user the materials
+    specified in Subsection 6a, above, for a charge no more
+    than the cost of performing this distribution.
+
+    d) If distribution of the work is made by offering access to copy
+    from a designated place, offer equivalent access to copy the above
+    specified materials from the same place.
+
+    e) Verify that the user has already received a copy of these
+    materials or that you have already sent this user a copy.
+
+  For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it.  However, as a special exception,
+the materials to be distributed need not include anything that is
+normally distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+  It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system.  Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+^L
+  7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+    a) Accompany the combined library with a copy of the same work
+    based on the Library, uncombined with any other library
+    facilities.  This must be distributed under the terms of the
+    Sections above.
+
+    b) Give prominent notice with the combined library of the fact
+    that part of it is a work based on the Library, and explaining
+    where to find the accompanying uncombined form of the same work.
+
+  8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License.  Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License.  However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+  9. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Library or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+  10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties with
+this License.
+^L
+  11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply, and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License
+may add an explicit geographical distribution limitation excluding those
+countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  13. The Free Software Foundation may publish revised and/or new
+versions of the Lesser General Public License from time to time.
+Such new versions will be similar in spirit to the present version,
+but may differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Library
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation.  If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+^L
+  14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+write to the author to ask for permission.  For software which is
+copyrighted by the Free Software Foundation, write to the Free
+Software Foundation; we sometimes make exceptions for this.  Our
+decision will be guided by the two goals of preserving the free status
+of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+                            NO WARRANTY
+
+  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
+LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+                     END OF TERMS AND CONDITIONS
+^L
+           How to Apply These Terms to Your New Libraries
+
+  If you develop a new library, and you want it to be of the greatest
+possible use to the public, we recommend making it free software that
+everyone can redistribute and change.  You can do so by permitting
+redistribution under these terms (or, alternatively, under the terms
+of the ordinary General Public License).
+
+  To apply these terms, attach the following notices to the library.
+It is safest to attach them to the start of each source file to most
+effectively convey the exclusion of warranty; and each file should
+have at least the "copyright" line and a pointer to where the full
+notice is found.
+
+
+    <one line to give the library's name and a brief idea of what it
+does.>
+    Copyright (C) <year>  <name of author>
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
+
+Also add information on how to contact you by electronic and paper
+mail.
+
+You should also get your employer (if you work as a programmer) or
+your
+school, if any, to sign a "copyright disclaimer" for the library, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the
+  library `Frob' (a library for tweaking knobs) written by James
+Random Hacker.
+
+  <signature of Ty Coon>, 1 April 1990
+  Ty Coon, President of Vice
+
+That's all there is to it!
+
+
diff --git a/libs/libgnomecanvasmm/ChangeLog b/libs/libgnomecanvasmm/ChangeLog
new file mode 100644
index 0000000000..5de1d36668
--- /dev/null
+++ b/libs/libgnomecanvasmm/ChangeLog
@@ -0,0 +1,556 @@
+2.10.0:
+
+2005-02-07  Cedric Gustin  <cedric.gustin@swing.be>
+
+	* build_shared/Makefile_build.am_fragment: added a few LDFLAGS 
+	for win32 DLLs (defined in win32_dlls_ldflags and appended to 
+	common_ldflags).
+
+2005-02-07  Michael Hofmann  <mh21@piware.de>
+
+	* configure.in: Added test of win32 platform and support for
+	MS-style bit alignment.
+	
+2005-02-02  Bradley Bell  <btb@debian.org>
+
+	* libgnomecanvasmm/src/item.ccg: item_construct(): Use an extra 
+	helper function to create an empty va_list, instead of passing 0 to 
+	gnome_canvas_item_construct(). Needed by the alpha platform. 
+	Bug # 136930.
+	
+2.8.0:
+	
+2004-09-12  Murray Cumming  <murrayc@murrayc.com>
+
+	* Increased version for GNOME 2.8 release version.
+
+2.6.1:
+
+2004-05-01  Takashi Takekawa <takekawa@users.sourceforge.jp>
+ 
+         * libgnomecanvas/libgnomecanvas.[h,cc] (GNOMEMM_PROPERTY,
+         GNOMEMM_PROPERTY_IMPL): fixed doubled '>' when T is a template class,
+         for the Intel compiler.
+         * libgnomecanvas/src/line.hg: deleted unnecessary namespace
+         qualification, for the Intel compiler.
+
+2.6.0:
+
+2004-04-12  Bryan Forbes  <bryan@reigndropsfall.net>
+
+	* tools/extra_defs_gen/Makefile.am: link against the 2.4 release of glibmm.
+
+2.5.2:
+
+2004-04-07  Bryan Forbes  <bryan@reigndropsfall.net>
+
+	* libgnomecanvas/src/canvas.hg: changed from using GdkRgbDither to
+	Gdk::RgbDither.
+	* libgnomecanvas/src/item.hg: changed from using GdkDrawable* to const
+	Glib::RefPtr<Gdk::Drawable>&.
+	* libgnomecanvas/src/text.hg: changed all C Pango properties to their C++
+	counterparts.
+
+2004-02-07  Alexander Nedotsukov <bland@FreeBSD.org>
+
+ 	* Fixed m4 files installation directory missed after 2.0 -> 2.6 change.
+
+2.5.1:
+ 
+2004-02-13  Murray Cumming  <murrayc@usa.net>
+
+	* Use the new libsigc++ 2 syntax.
+
+2003-12-21  Eric Bourque <ericb@computer.org>
+	* libgnomecanvasmm.spec.in: fixed dependency to gtkmm2 instead of gtkmm
+
+2003-12-19  Murray Cumming  <murrayc@usa.net>
+
+	* libgnomecanvas/src/widget.hg: Use a Gtk::Widget* instead of a
+	Gtk::Widget for the widget property.
+
+2.5.0:
+
+2003-11-03  Murray Cumming  <murrayc@usa.net>
+
+	* This is now libgnomecanvasmm 2.5, which will become libgnomecanvasmm
+	2.6. This is on HEAD, and libgnomecanvasmm 2.0 is on the gnome-2-4
+	branch. This uses gtkmm 2.4 and is parallel-installable.
+
+2003-09-25  Eric Bourque <ericb@computer.org>
+	* libgnomecanvasmm.spec.in: updated for libgnomecanvasmm-2.0
+	
+2.0.1:
+	
+2003-08-22  Murray Cumming  <murrayc@usa.net>
+
+	* examples/Makefile.am: Fixed the distcheck.
+
+
+2003-07-21  Murray Cumming  <murrayc@usa.net>
+
+	* libgnomecanvas/src/canvas.hg: Use the new GMMPROC_PROTECTED_GCLASS
+	macro on the Canvas class so that the CanvasAA class can access
+	canvas_class_.
+	* libgnomecanvas/src/canvas.ccg: Rewrite the CanvasAA constructor to 
+	use the new (and working) gtkmm2-style construction construction. Fixes
+	bug #107686.
+	* configure.in: Now requires gtkmm 2.2.5, which has the new macro.
+
+2.0.0:
+
+2002-12-10  Bradley Bell  <btb@debian.org>
+	
+ 	* scripts/Makefile.am: distribute macros.m4
+	
+2002-12-10  Andreas Holzmann  <Andreas.Holzmann@epost.de>
+
+	* Properties: Files renamed to be more conform with the rest,
+	moved implementation from header into implementation file,
+	some typos fixed, some properties added.
+
+2002-12-09  Andreas Holzmann  <Andreas.Holzmann@epost.de>	
+
+	* libgnomecanvas/src/rich-text.[ccg|hg]: Replaced 
+	void get_iter_at_location(const Gtk::TextIter&, int, int) with
+	iterator get_iter_at_location(int, int) const to be more conform
+	with Gtkmm iterator methods.
+	* libgnomecanvas/src/canvas.[ccg|hg]: The following methods are
+	now const: root(), get_scroll_region(), get_center_scroll_region(),
+	w2c(), and get_color()
+	* libgnomecanvas/libgnomecanvasmm/affinetrans.[cc,h]: Changed
+	bool operator==(AffineTrans&) to 
+	bool operator==(const AffineTrans&) const
+	* demos/primitives.cc: Fixed pack_start() Gtk::AttachOptions.
+	* examples/Makefile.am_fragment: Was missing in CVS (I took it from
+	the release candidate).
+	* libgnomecanvas/src/libgnomecanvas_docs_override.xml: Was missing
+	in CVS (I took it from the release candidate).
+
+2002-12-09  Murray Cumming  <murrayc@usa.net>
+
+	* libgnomecanvas/*.pc.in: Changed LIBS from 1.3 to 2.0.
+
+2002-12-09  Murray Cumming  <murrayc@usa.net>
+
+	* Merging C docs: Added libgnomecavas/src/libgnomecavas_docs.xml and 
+	libgnomecanvas_docs_override.xml, and added --mergecdocs to 
+	build_shared/Makefile_gensrc.am_fragment
+	* examples: Created separated directories for each example, with each
+	Makefile.am including examples/Makefile.am_fragment, like the other
+	*mm projects. Unlike the other projects, the examples build as part
+	of the main build, because there aren't many.
+
+2002-12-09  Murray Cumming <murrayc@usa.net>
+
+	* Increased version to 2.0.0, renamed library from 1.3 to 2.0.
+
+1.3.11:
+	
+2002-09-28  Owen Stenseth  <owen@bonemachine.org>
+
+	* demos/primitives.cc: Set center_scroll_region to false as the
+	libgnomecanvas demo does.
+	
+1.3.10:
+	
+2002-08-15  ERDI Gergo  <cactus@cactus.rulez.org>
+
+	* libgnomecanvas/libgnomecanvasmm/canvas-property.cc
+	(Property<Gdk::Color>::set_value_in_object): Clear color property if input string is ""
+	(Property<Pango::FontDescription>): Moved implementation to .cc file
+
+1.3.9:
+	
+2002-08-08  ERDI Gergo  <cactus@cactus.rulez.org>
+
+	* libgnomecanvas/src/shape.hg: 
+	* libgnomecanvas/src/line.hg: 
+	* libgnomecanvas/src/text.hg: 
+	* libgnomecanvas/libgnomecanvasmm/canvas-property.h: Changed
+	stipple properties to use correct Gdk::Bitmap param type instead
+	of Gdk::Pixmap and Gdk::Drawable
+
+2002-07-25  Michael Babcock <mbabcock@la.creatureshop.henson.com>
+	* libgnomecanvas/libgnomecanvasmm/point.cc: gobj(): Avoid infinite
+	recursion.
+
+2002-07-24  Erwin J. van Eijk  <kojak@oakhill.demon.nl>
+
+	* examples/canvas/canvas_events.cc:
+	One of the examples, canvas_events caused an infinite recursion
+	to occur. I've patched canvas_events to be more like canvas.cc,
+	and not to cause the recursion.
+
+2002-07-19  Murray Cumming  <murrayc@usa.net>
+
+	* Updated examples for latest gtkmm pack_start() method.
+
+1.3.8:
+	
+2002-07-16  Murray Cumming  <murrayc@usa.net>
+
+	* Rebuilt for latest gtkmm.
+
+1.3.7:
+	
+2002-06-23  Murray Cumming  <murrayc@usa.net>
+
+	* Rebuilt for latest gtkmm.
+
+1.3.6:
+	
+2002-06-11  Andreas Holzmann  <Andreas.Holzmann@epost.de>
+
+	* libgnomecanvas/libgnomecanvasmm.h: Add missing include
+	<libgnomecanvasmm/widget.h>
+	(#84704, reported by abes@memlab1.ccs.brandeis.edu)
+
+2002-06-02  Daniel Elstner  <daniel.elstner@gmx.net>
+
+	* libgnomecanvas/src/pixbuf.hg (property_pixbuf): Change the
+	property type to Glib::RefPtr<Gdk::Pixbuf>.  (Reported by
+	Ole Laursen <olau@hardworking.dk>.)
+
+2002-05-14  Daniel Elstner  <daniel.elstner@gmx.net>
+
+	* libgnomecanvas/src/line.hg (Canvas::Points::is_null): Remove
+	'virtual' keyword.  There is no need for is_null() to be virtual,
+	and gcc-3.1 issues a warning because the dtor isn't virtual too.
+
+	* libgnomecanvas/libgnomecanvasmm/affinetrans.cc: Remove default
+	method arguments from the implementation prototype -- gcc-3.1
+	doesn't like them at all.  Also, remove the now unnecessary cast
+	to std::string in operator<<().
+
+2002-05-14  Andreas Holzmann  <Andreas.Holzmann@epost.de>
+
+	* demos/*.cc: Use new Gtk::Box::pack_start() API.
+	* configure.in: Require gtkmm version 1.3.14. Require libgnomecanvas
+	version 1.113 because of function set_center_scroll_region().
+
+2002-05-07  Andreas Holzmann  <Andreas.Holzmann@epost.de>
+
+	* demos/canvas.cc: Use new Gtk::Notebook API.
+	* libgnomecanvas/src/line.[ccg|hg]: Add Glib::Value<>
+	specialization for Points class.
+	* configure.in: Require gtkmm version 1.3.13.
+	
+1.3.5:
+	
+2002-04-23  Murray Cumming  <murrayc@usa.net>
+
+	* generated sources are now distributed. The am_fragments in 
+	build_files are now abstracted for all Gnome::Something libraries, 
+	so I can now just copy them into the other libraries.
+
+1.3.4:
+	
+2002-04-04  Andreas Holzmann  <Andreas.Holzmann@epost.de>
+
+	* Use new Glib::Value and Glib::PropertyProxy implementation.
+	* Use new namespace enums.
+	
+2002-04-01  Murray Cumming  <murrayc@usa.net>
+
+	* Use new _DEFS() format in *.hg.
+	
+2002-03-27  Murray Cumming  <murrayc@usa.net>
+
+	* PathDef: Use new _CLASS_OPAQUE_REFCOUNTED macro instead of
+	_CLASS_BOXEDTYPE.
+
+2002-03-17  Murray Cumming  <murrayc@usa.net>
+
+	* Added BoxedType-like methods to Gnome::Points, so that it can
+	be used for Properties.
+
+2002-03-16  Murary Cumming  <murrayc@usa.net>
+
+	* Gnome::Art::AffineTrans and Gnome::Art::Point obj() methods
+	renamed to gobj(), to conform to match everything else.
+
+2002-03-15  Andreas Holzmann <Andreas.Holzmann@epost.de>
+
+	* libgnomecanvas/src/canvas.[hg|ccg] 
+	(set_center_scroll_region,
+	 get_center_scroll_region): New functions wrapped.
+	* libgnomecanvas/src/bpath.[hg|ccg]: New wrapper for GnomeCanvasBpath.
+	* libgnomecanvas/src/path-def.[hg|ccg]: New wrapper for 
+	GnomeCanvasPathDef.
+	* demos/*: Missing curve demos added. More conform to coding standards.
+
+1.3.3:
+2002-03-10  Murray Cumming  <murrayc@usa.net>
+
+	* Changed signal args to C++ types.
+
+2002-02-24  Murray Cumming  <murrayc@usa.net>
+
+	* Renamed canvas-*.[h.cc] to *.[h.cc]. They were previously prefixed
+	by canvas- to make things clearer when they were part of libgnomeui.
+	This means you should probably manually delete any installed 
+	libgnomecanvasmm headers or make uninstall a previous version. 
+
+2002-02-24  Andreas Holzmann  <Andreas.Holzmann@epost.de>
+
+	* docs/reference generation fixed
+	* libgnomecanvas/src/canvas.[hg|ccg]:
+	  + Antialiased canvas constructor fixed
+	  + aa property changed from gulong to bool
+	* libgnomecanvas/src/pixbuf.[hg|ccg]: implemented
+	* libgnomecanvas/src/rich-text.[hg|ccg]: implemented
+	* Added demo, based on the C demo - needs some more
+	classes to be implemented.
+
+1.3.2:
+	
+2002-02-20  Murray Cumming  <murrayc@usa.net>
+
+	* Wrapped remaining methods and signals in Canvas and Item.
+	* Art::Affine(const double[6]) constructor is now explicit, and
+	the arg is const, with a fixed array size.
+	* Increased version number.
+
+2002-02-17  Murray Cumming  <murrayc@usa.net>
+
+	* Removed an if{} check from init(). This would have prevented
+	Gnome::Canvas::init() or Gnome::Conf::init() from working after one 
+	of them had run first.
+
+2002-02-15  Murray Cumming  <murrayc@usa.net>
+
+	* Added GnomeCanvasShape wrapper, and corrected RectEllpise and 
+	Polygon to inherit from it. 
+
+2002-02-15  Andreas Holzmann  <Andreas.Holzmann@epost.de>
+
+	* Fixed name and description in the pkg-config file.
+	* Uncommented Canvas::get_item_at(). Don't know why it was commented.
+
+Release 1:3.1:
+	
+	vfuncs.defs parsing problems solved. Updated for latest gtkmm
+	
+Release 1.3.0:
+
+2002-01-08  Murray Cumming  <murrayc@usa.net>
+
+	* canvas-properties.[h|c]: Properly implemented the shared 
+	streams-based properties, using the gtkmm2 PropertyProxy* templates,
+	and put them in the Gnome::Canvas::Properties namespace instead of
+	Gnome::CanvasHelpers.
+	I think that the implementation is much clearer than before.
+	We probably need to review the properties in case any streams-based
+	properties need to be added.
+
+2002-01-05  Murray Cumming  <murrayc@usa.net>
+
+	* Change properties to normal gtkmm-1.3 properties. The 
+	streams-based shared property objects need more work so they 
+	can deal with BoxedType and Glib::Object properties. However, this
+	streams stuff is separate from normal property proxies.
+
+2002-01-04  Murray Cumming  <murrayc@usa.net>
+
+	* Canvas::CanvasGroup, Canvas::CanvasItem, etc are now 
+	Canvas::Group, Canvas::Item, etc. Canvas::RE is now 
+	Canvas::RectEllipse.
+
+2002-01-03  Murray Cumming  <murrayc@usa.net>
+
+	* Moved things into the Gnome::Canvas namespace. We might want to 
+	rename things such as Gnome::Canvas::CanvasGroup to 
+	Gnome::Canvas::Group.
+
+2002-01-02  ERDI Gergo  <cactus@cactus.rulez.org>
+
+	* libgnomecanvas/src/canvas-text.hg:
+	* libgnomecanvas/src/canvas-polygon.hg:
+	* libgnomecanvas/src/canvas-line.hg: Use Gdk::Bitmaps instead of
+	Gdk::Pixmaps for stipples
+
+2001-12-15  Murray Cumming  <murrayc@usa.net>
+
+	* Committed Paul Davis's first patch to properly wrap the old
+	CanvasItem 'signals' as vfuncs, using his hand-written 
+	libgnomecanvas_vfuncs.defs. He also fixed the canvas/canvas 
+	example, which now runs.
+	* Fixed libgnomecanvasmm.h and added Gnome::canvas_init() which
+	should be used before Gtk::Main, if you are not using libgnomeuimm 
+	and Gnome::Main.
+
+2001-12-12  Murray Cumming  <murrayc@usa.net>
+
+	* Changed build files to use -I instead of --m4 with
+	gtkmmproc, as needed by the latest gtkmm-1.3. The new
+	gtkmmproc doesn't seem to be picking up the libgnomecanvasmm
+	conversions so I had to comment out a _MEMBER_GET in CanvasItem.
+
+2001-12-11  Murray Cumming  <murrayc@usa.net>
+
+	* Gnome::wrap_init() is now Gnome::canvas_wrap_init()
+	to avoid a clash with other wrap_init() functions. This
+	requires the latest gtkmm-1.3.
+
+2001-12-04  Murray Cumming  <murrayc@usa.net>
+
+	* Created libgnomecanvasmm for libgnomeui in GNOME2.
+
+The following notes are from gnome-- 1.2.x, which previously
+contained the GnomeCanvas wrappers:
+
+Release 1.2.2
+  * Gnome::UI::Help fixed: This should be added to the
+    Help menu to automatically add items from the
+    topics.dat file. (Murray Cumming)
+  * gnome-hello example: The About box is now closed
+    and deleted when [Close] is clicked
+    (Murray Cumming)
+	
+Release 1.2.1
+  * App::create_toolbars fixed to use member UI::Array.
+    This allows access to the widgets, as well as
+    properly managing memory for the UI Items.
+    - menu example modified to demonstrate disabling
+      of menu item widgets. (Murray Cumming)
+  * configure.in: Don't add -I$prefix/include to
+    GNOMEMM_INCLUDEDIR if $prefix=/usr. -I/usr/include
+    should never be used because it overrides the order
+    of gcc's implicit include path. gtkmm-config.in has
+    been corrected too. (Daniel Elstner)
+  * Dialog, MessageBox, PropertyBox: Added extra
+    documentation so people know that these are not
+    self-destructed when run() or run_and_close()
+    returns. (Murray Cumming)
+
+Release 1.2.0
+  * Canvas example:
+      Added example.png to test CanvasImage.
+      Items are now deleted in the destructor.
+      (Murray Cumming)
+  * Reference Documentation:
+      Location of perl not hardcoded. (Cedric Gustin)
+  * Some gcc 3.0 std namespace fixes. (Claudio Bley)
+
+Release 1.1.21
+  * CanvasText: set_font(const GdkFont&) conversion
+    fixed and set_font(const string&) added.
+    (Murray Cumming)
+  * CanvasItem: event signal marshalled again. We lost
+    this fix sometime after 1.1.17. (Gergõ Érdi)
+  * Uncommented the CanvasHelper::anchor property,
+    adding the necessary gtkpacker.h #include.
+    (Murray Cumming)
+  * Fixed CanvasHelpers::font for Gdk_Font input and
+    added a string constructor. (Murray Cumming)
+  * Added CanvasText::set_fontset(). (Murray Cumming)
+
+Release 1.1.20
+  Unofficial, with some 1.1.21 changes.
+
+Release 1.1.19
+  * canvas-property.h is installed.
+    (Murray Cumming)
+
+Release 1.1.18
+  * Namespace and other fixes for gcc 3.
+    (Murray Cumming and Joe Yandle)
+  * New Canvas API (KEN)
+      Adds streams-style interface. See examples.
+  * MDIChild:
+      Comments in code.
+      Implemented set_config_string(), remove_view(),
+      and set_active(). (Murray Cumming)
+
+
+Release 1.1.17
+  * Improved configure checks for Gtkmm and libsigc++.
+    (Eric Bourque)
+  * App:
+    create_menus() and create_toolbar() now
+    return UI::Array<>s that provide the widget
+    pointers.
+    Added insert_menus() and remove_menus().
+    Added menu example, to demonstrate access to menu
+    item widgets and insert_menus().
+    (Murray Cumming)
+  * Added Gnome::Pixmap::find_file() as wrapper for
+    gnome_pixmap_file(). (Murray Cumming)
+  * CanvasItem::event()'s propagation can be stopped by
+    returning TRUE in signal handler (Gergõ Érdi)
+
+Release 1.1.16
+  * Fixed AppBar default constructor. (Murray Cumming)
+  * Improved Point and AffineTrans wrappers. Put them in
+    their own point.h/.cc and affinetrans.h/.cc files,
+    in the Gnome::Art namespace.
+    (Agustin Ferrin Pozuelo)
+  * Added canvas_events example. (Agustin Ferrin Pozuelo)
+  * Added canvas_affine example. (Agustin Ferrin Pozuelo)
+  * configure: fixed check for perl. (Agustin Ferrin Pozuelo)
+  * IconList: Removed default constructor. Fixed signals.
+    Added selection() method, with SelectionList.
+    Added examples.
+    (Andreas Holzmann)
+  * Canvas, CanvasItem: Changed some pointer args to
+    references (Andreas Holzmann).
+  * AM_PATH_GNOMEMM() macro installed.
+    (Agustin Ferrin Pozuelo)
+
+Release 1.1.15
+  * Changed AffineTrans::operator[] to return reference.
+    (Falk Hueffner)
+  * Examples now quit when close button is clicked,
+    instead of just hiding their windows.
+    (Murray Cumming)
+  * Fixed Clock constructor problems, and
+    added demo. (Murray Cumming)
+  * CanvasItem sub-classes:
+    - Removed default constructors - there's nothing
+      in libgnomeui for these.
+    - IconTextItem (icon-item.gen_h): Constructors are now
+      like other CanvasItems. (Murray Cumming)
+  * Fixed Druid constructor problems, and
+    added demo. (Murray Cumming)
+  * Fixed MessageBox constructor problems, and
+    added demo. (Murray Cumming)
+  * Fixed Dialog self-destruct by correcting
+    close signal wrapping. (Karl Nelson)
+  * Dialogs (and sub-classes) now use close_hides()
+    as default, to prevent self-destruction.
+    (Murray Cumming)
+  * Reference documentation now builds
+    (Murray Cumming)
+   * Fixes to app-helper to allow Slot1<void,Gtk::Widget*> and
+      Slot0<void> on UI::Info items. (Karl Nelson)
+
+
+==================================================================
+
+Release 1.1.14
+  ?
+
+==================================================================
+
+Release 1.1.13
+  * Static string problem on initialization
+  * gcc 2.96 fixes.
+
+==================================================================
+
+Release 1.1.12
+  * Massive cleanup of internals (Murray Cumming)
+  * Animator and demo (Murray Cumming)
+  * HRef (Murray Cumming)
+  * Fixes to UIInfo (Murray Cumming)
+  * added add_button to dialog (Murray Cumming)
+  * cleanups of types to match GNOME
+  * Canvas fixes (Sebastian Rittau)
+  * MDI fixes (Manuel Clos and Sebastian Rittau)
+  * Complete demo for MDI (Manuel Clos)
+  * Added radio items (Karl)
+  * Improved UIInfo conversions (Karl)
+  * Demos for UIInfo (Karl)
+  * STL name cleanups (Karl)
+
diff --git a/libs/libgnomecanvasmm/NEWS b/libs/libgnomecanvasmm/NEWS
new file mode 100644
index 0000000000..f3bf80dcef
--- /dev/null
+++ b/libs/libgnomecanvasmm/NEWS
@@ -0,0 +1,54 @@
+2.10.0:
+
+* Increased version for GNOME 2.10 release version.
+* WIN32 build fixes. (Cedric Gustin, Michael Hofmann)
+* Alpha build fix (Bradley Bell)
+
+2.8.0:
+
+* Increased version for GNOME 2.8 release version.
+
+2.6.1:
+
+* Build fixes for gcc 3.4 and for the Intel compiler.
+  (Takashi Takekawa)
+
+2.6.0:
+
+Increased version.
+
+2.5.2:
+
+* Canvas: set_dither(), get_dither(): Use C++ enum instead of C enum.
+* Item: draw(): Use C++ Gdk::Drawable instead of C type.  
+* Text: Changed all C Pango properties to their C++
+  counterparts.
+(Bryan Forbes)
+
+
+2.5.1:
+
+* Use new libsigc++ 2 syntax.
+* Canvas::Widget: Use a Gtk::Widget* for the "widget" property,
+  instead of Gtk::Widget, so that it is usable.
+(Murray Cumming)
+* Spec file dependency fix. (Eric Bourque)
+
+2.5.0:
+ 
+This is the new unstable branch of the parallel-installable 
+libgnomevanvasmm 2.6, for use with gtkmm 2.4.
+
+2.0.1:
+
+* Corrected segfault in CanvasAA destructor.
+  The AA Canvas was probably useless before this.
+  (Murray Cumming)
+
+2.0.0:
+
+Documentation:
+* Reuses C documentation.
+* examples separated into individual directories.
+
+1.3.11:
diff --git a/libs/libgnomecanvasmm/README b/libs/libgnomecanvasmm/README
new file mode 100644
index 0000000000..e70affef6f
--- /dev/null
+++ b/libs/libgnomecanvasmm/README
@@ -0,0 +1 @@
+libgnomecanvasmm provides C++ wrappers for libgnomecanvas, for use with gtkmm.
\ No newline at end of file
diff --git a/libs/libgnomecanvasmm/SConscript b/libs/libgnomecanvasmm/SConscript
new file mode 100644
index 0000000000..c53d218d94
--- /dev/null
+++ b/libs/libgnomecanvasmm/SConscript
@@ -0,0 +1,10 @@
+import glob
+
+gnomecanvasmm_files = glob.glob('libgnomecanvasmm/*.cc')
+
+Import('env libraries')
+gnomecanvasmm = env.Copy()
+gnomecanvasmm.Merge([libraries['glibmm2'], libraries['gtk2'], libraries['sigc2'], libraries['pangomm'], libraries['atkmm'], libraries['gdkmm2'], libraries['gtkmm2'], libraries['libgnomecanvas2'] ])
+
+libgnomecanvasmm = gnomecanvasmm.StaticLibrary('libgnomecanvasmm', gnomecanvasmm_files)
+Default(libgnomecanvasmm)
diff --git a/libs/libgnomecanvasmm/TODO b/libs/libgnomecanvasmm/TODO
new file mode 100644
index 0000000000..83b2a478f0
--- /dev/null
+++ b/libs/libgnomecanvasmm/TODO
@@ -0,0 +1,8 @@
+LIBGNOMECANVASMM:
+
+* Rename canvas-*.hg to *.hg.
+* Check that we have all the necessary streams-based properties.
+
+
+
+
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm.h b/libs/libgnomecanvasmm/libgnomecanvasmm.h
new file mode 100644
index 0000000000..a745189d5e
--- /dev/null
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm.h
@@ -0,0 +1,45 @@
+/* $Id$ */
+/* libgnomecanvasmm - a C++ wrapper for libgnomecanvas
+ *
+ * Copyright 1999-2001 Free Software Foundation
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ifndef LIBGNOMECANVASMM_H
+#define LIBGNOMECANVASMM_H
+
+/* libgnomecanvasmm version.  */
+extern const int libgnomecanvasmm_major_version;
+extern const int libgnomecanvasmm_minor_version;
+extern const int libgnomecanvasmm_micro_version;
+
+#include <gtkmm.h>
+
+#include <libgnomecanvasmm/canvas.h>
+#include <libgnomecanvasmm/properties.h>
+#include <libgnomecanvasmm/group.h>
+#include <libgnomecanvasmm/init.h>
+#include <libgnomecanvasmm/line.h>
+#include <libgnomecanvasmm/ellipse.h>
+#include <libgnomecanvasmm/pixbuf.h>
+#include <libgnomecanvasmm/point.h>
+#include <libgnomecanvasmm/rect.h>
+#include <libgnomecanvasmm/rect-ellipse.h>
+#include <libgnomecanvasmm/rich-text.h>
+#include <libgnomecanvasmm/text.h>
+#include <libgnomecanvasmm/widget.h>
+
+#endif /* #ifndef LIBGNOMECANVASMM_H */
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/.DS_Store b/libs/libgnomecanvasmm/libgnomecanvasmm/.DS_Store
new file mode 100644
index 0000000000..693c13e9f3
--- /dev/null
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/.DS_Store
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/affinetrans.cc b/libs/libgnomecanvasmm/libgnomecanvasmm/affinetrans.cc
new file mode 100644
index 0000000000..f483e7022e
--- /dev/null
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/affinetrans.cc
@@ -0,0 +1,234 @@
+// -*- C++ -*-
+/* $Id$ */
+
+/* affinetrans.h
+ * 
+ * Copyright (C) 1999 The gnomemm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <libgnomecanvasmm/affinetrans.h>
+#include <libgnomecanvas/gnome-canvas.h>
+
+namespace Gnome
+{
+
+namespace Art
+{
+
+AffineTrans::AffineTrans(double scale)
+{
+  trans_[0] = scale;
+  trans_[1] = 0.0;
+  trans_[2] = 0.0;
+  trans_[3] = scale;
+  trans_[4] = 0.0;
+  trans_[5] = 0.0;
+}
+
+AffineTrans::AffineTrans(const double aff[6])
+{
+	trans_[0] = aff[0];
+	trans_[1] = aff[1];
+	trans_[2] = aff[2];
+	trans_[3] = aff[3];
+	trans_[4] = aff[4];
+	trans_[5] = aff[5];
+}
+
+AffineTrans::AffineTrans(const AffineTrans& src)
+{
+  operator=(src);
+}
+
+AffineTrans::~AffineTrans()
+{
+}
+
+AffineTrans& AffineTrans::operator=(const AffineTrans& src)
+{
+  for(unsigned int i = 0; i < 6; i++)
+  {
+    trans_[i] = src.trans_[i];
+  }
+
+  return *this;
+}
+
+double&
+AffineTrans::operator[](unsigned int idx)
+{
+  if(idx > 5)
+  {
+    g_warning("AffineTrans::operator[] called with idx > 5");
+    return trans_[5]; //0; //Can't convert 0 to double& - throw exception?
+  }
+
+  return trans_[idx];
+}
+
+const double&
+AffineTrans::operator[](unsigned int idx) const
+{
+  if(idx > 5)
+  {
+    g_warning("AffineTrans::operator[] const called with idx > 5");
+    return trans_[5]; //0; //Can't convert 0 to double& - throw exception?
+  }
+
+  return trans_[idx];
+}
+
+Point AffineTrans::apply_to(const Point& p) const
+{
+  Point result;
+  art_affine_point(result.gobj(), p.gobj(), trans_);
+  return result;
+}
+  
+Point AffineTrans::operator*(const Point& p) const
+{
+  return apply_to(p);
+}
+
+AffineTrans
+AffineTrans::operator*(const AffineTrans& aff2)
+{
+  AffineTrans result;
+  art_affine_multiply(result.gobj(), gobj(), aff2.gobj());
+  return result;
+}
+
+bool AffineTrans::operator==(const AffineTrans& other) const
+{
+  return (bool)art_affine_equal(const_cast<double*>(trans_),
+                                const_cast<double*>(other.gobj()));
+}
+ 
+bool AffineTrans::operator!=(const AffineTrans& other) const
+{
+  return !(bool)art_affine_equal(const_cast<double*>(trans_),
+                                 const_cast<double*>(other.gobj()));
+}
+                        
+void AffineTrans::invert()
+{
+  art_affine_invert(trans_, trans_);
+}
+  
+void AffineTrans::flip(bool horiz, bool vert)
+{
+  art_affine_flip(trans_, trans_, horiz, vert);
+}
+
+bool AffineTrans::rectilinear() const
+{
+  return art_affine_rectilinear(trans_);
+}
+
+double AffineTrans::expansion() const
+{
+  return art_affine_expansion(trans_);
+}
+
+AffineTrans const &
+AffineTrans::operator*=(AffineTrans& other)
+{
+  art_affine_multiply(gobj(), gobj(), other.gobj());
+  return *this;
+}
+
+
+AffineTrans AffineTrans::identity()
+{
+  AffineTrans tmp;
+	art_affine_identity(tmp.gobj());
+	return tmp;
+}
+
+AffineTrans
+AffineTrans::scaling(double s)
+{
+  return scaling(s, s);
+}
+
+AffineTrans
+AffineTrans::scaling(double sx, double sy)
+{
+	AffineTrans tmp;
+	art_affine_scale(tmp.gobj(), sx, sy);
+	return tmp;
+}
+
+AffineTrans
+AffineTrans::rotation(double theta)
+{
+	AffineTrans tmp;
+	art_affine_rotate(tmp.gobj(), theta);
+	return tmp;
+}
+
+AffineTrans
+AffineTrans::translation(double dx, double dy)
+{
+	AffineTrans tmp;
+	art_affine_translate(tmp.gobj(), dx, dy);
+	return tmp;
+}
+
+AffineTrans
+AffineTrans::translation(const Point& p)
+{
+	AffineTrans tmp;
+	art_affine_translate(tmp.gobj(), p.get_x(), p.get_y());
+	return tmp;
+}
+
+
+AffineTrans
+AffineTrans::shearing(double theta)
+{
+	AffineTrans tmp;
+	art_affine_shear(tmp.gobj(), theta);
+	return tmp;
+}
+
+double* AffineTrans::gobj()
+{
+  return trans_;
+} 
+
+const double* AffineTrans::gobj() const
+{
+  return trans_;
+}
+
+Glib::ustring AffineTrans::to_string() const
+{
+  char pchStr[128];
+  pchStr[127] = 0; //Just in case art_affine_to_string doesn't work properly.
+  art_affine_to_string(pchStr, gobj());
+  return Glib::ustring(pchStr);
+}
+
+} //namespace Art
+
+} //namespace Gnome
+
+std::ostream& operator<<(std::ostream& out, const Gnome::Art::AffineTrans& aff)
+{
+  return out << aff.to_string();
+}
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/affinetrans.h b/libs/libgnomecanvasmm/libgnomecanvasmm/affinetrans.h
new file mode 100644
index 0000000000..b04648963d
--- /dev/null
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/affinetrans.h
@@ -0,0 +1,119 @@
+#ifndef _LIBGNOMECANVASMM_AFFINETRANS_H
+#define _LIBGNOMECANVASMM_AFFINETRANS_H
+
+// -*- C++ -*-
+/* $Id$ */
+
+/* affinetrans.h
+ * 
+ * Copyright (C) 1999 The gnomemm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <glibmm/containers.h>
+#include <libgnomecanvasmm/point.h>
+
+namespace Gnome
+{
+
+namespace Art
+{
+
+//: Used by CanvasItem.
+class AffineTrans
+{
+public:
+  //: Initialize the affine as unit matrix, with a scaling factor
+  AffineTrans(double scale = 1.0);
+
+  //: aff[6]
+  explicit AffineTrans(const double aff[6]);
+
+  AffineTrans(const AffineTrans& src);
+  AffineTrans& operator=(const AffineTrans& src);
+  ~AffineTrans();
+   
+  double& operator[](unsigned int idx);
+  const double& operator[](unsigned int idx) const;
+
+  double* gobj();
+  const double* gobj() const;
+
+  //: Apply the affine to a given point
+  //: e.g. Point dst = affine.apply(Point(x,y));
+  //: is the same as:
+  //: dst.x = x * affine[0] + y * affine[2] + affine[4];
+  //: dst.y = x * affine[1] + y * affine[3] + affine[5];
+  Point apply_to(const Point& p) const;
+  
+  //: Apply the affine to a given point
+  Point operator*(const Point& p) const;
+	
+  //: Compose two affines
+  AffineTrans operator*(const AffineTrans& aff2);
+	
+  //: Apply other affine to the affine
+  AffineTrans const & operator*=(AffineTrans& other);
+  
+  bool operator==(const AffineTrans& other) const;
+  bool operator!=(const AffineTrans& other) const;
+                        
+  //: Give the inverse of the affine
+  void invert();
+  
+  //: Flip horizontally and/or vertically the affine
+  void flip(bool horiz, bool vert);
+
+  //: Determine whether the affine is rectilinear (rotates 0, 90, 180 or 270 degrees)
+  bool rectilinear() const;
+
+  //: Find the affine's "expansion factor", i.e. the scale amount
+  double expansion() const;
+
+  //: Set up the identity matrix
+  static AffineTrans identity();
+
+  //: Set up a scaling matrix
+  static AffineTrans scaling(double s);
+
+  //: Set up a scaling matrix
+  static AffineTrans scaling(double sx, double sy);
+
+  //: Set up a rotation matrix; theta is given in degrees
+  static AffineTrans rotation(double theta);
+
+  //: Set up a shearing matrix; theta given in degrees
+  static AffineTrans shearing(double theta);
+
+  //: Set up a translation matrix
+  static AffineTrans translation(double dx, double dy);
+
+  //: Set up a translation matrix
+  static AffineTrans translation(const Point& p);
+
+  Glib::ustring to_string() const;
+
+protected:
+  double trans_[6];
+};
+
+} //namespace Art
+
+} /* namespace Gnome */
+
+std::ostream& operator<<(std::ostream& out, const Gnome::Art::AffineTrans& aff);
+
+#endif // _GNOMEMM_AFFINETRANS_H
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/bpath.cc b/libs/libgnomecanvasmm/libgnomecanvasmm/bpath.cc
new file mode 100644
index 0000000000..6843922029
--- /dev/null
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/bpath.cc
@@ -0,0 +1,156 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <libgnomecanvasmm/bpath.h>
+#include <libgnomecanvasmm/private/bpath_p.h>
+
+/* bpath.cc
+ *
+ * Copyright (C) 2002 The libgnomecanvasmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+namespace Gnome
+{
+
+namespace Canvas
+{
+
+
+Bpath::Bpath(Group& parent)
+  : Shape(GNOME_CANVAS_SHAPE(g_object_new(get_type(),0)))
+{
+  item_construct(parent);
+}
+
+
+void Bpath::set_bpath(const Glib::RefPtr<PathDef>& path)
+{
+  property_bpath ().set_value ((gpointer)path->gobj());
+}
+
+
+} /* namespace Canvas */
+
+} /* namespace Gnome */
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gnome::Canvas::Bpath* wrap(GnomeCanvasBpath* object, bool take_copy)
+{
+  return dynamic_cast<Gnome::Canvas::Bpath *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gnome
+{
+
+namespace Canvas
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& Bpath_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &Bpath_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gnome_canvas_bpath_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void Bpath_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* Bpath_Class::wrap_new(GObject* o)
+{
+  return manage(new Bpath((GnomeCanvasBpath*)(o)));
+
+}
+
+
+/* The implementation: */
+
+Bpath::Bpath(const Glib::ConstructParams& construct_params)
+:
+  Shape(construct_params)
+{
+  }
+
+Bpath::Bpath(GnomeCanvasBpath* castitem)
+:
+  Shape((GnomeCanvasShape*)(castitem))
+{
+  }
+
+Bpath::~Bpath()
+{
+  destroy_();
+}
+
+Bpath::CppClassType Bpath::bpath_class_; // initialize static member
+
+GType Bpath::get_type()
+{
+  return bpath_class_.init().get_type();
+}
+
+GType Bpath::get_base_type()
+{
+  return gnome_canvas_bpath_get_type();
+}
+
+
+Glib::PropertyProxy<gpointer> Bpath::property_bpath() 
+{
+  return Glib::PropertyProxy<gpointer>(this, "bpath");
+}
+
+Glib::PropertyProxy_ReadOnly<gpointer> Bpath::property_bpath() const
+{
+  return Glib::PropertyProxy_ReadOnly<gpointer>(this, "bpath");
+}
+
+
+} // namespace Canvas
+
+} // namespace Gnome
+
+
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/bpath.h b/libs/libgnomecanvasmm/libgnomecanvasmm/bpath.h
new file mode 100644
index 0000000000..145b087a2e
--- /dev/null
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/bpath.h
@@ -0,0 +1,148 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _LIBGNOMECANVASMM_BPATH_H
+#define _LIBGNOMECANVASMM_BPATH_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* bpath.h
+ * 
+ *
+ * Copyright (C) 2002 The libgnomecanvasmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <libgnomecanvasmm/shape.h>
+#include <libgnomecanvasmm/path-def.h>
+#include <libgnomecanvas/gnome-canvas-bpath.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GnomeCanvasBpath GnomeCanvasBpath;
+typedef struct _GnomeCanvasBpathClass GnomeCanvasBpathClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gnome
+{
+
+namespace Canvas
+{ class Bpath_Class; } // namespace Canvas
+
+} // namespace Gnome
+namespace Gnome
+{
+
+namespace Canvas
+{
+
+
+class Bpath : public Shape
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Bpath CppObjectType;
+  typedef Bpath_Class CppClassType;
+  typedef GnomeCanvasBpath BaseObjectType;
+  typedef GnomeCanvasBpathClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~Bpath();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class Bpath_Class;
+  static CppClassType bpath_class_;
+
+  // noncopyable
+  Bpath(const Bpath&);
+  Bpath& operator=(const Bpath&);
+
+protected:
+  explicit Bpath(const Glib::ConstructParams& construct_params);
+  explicit Bpath(GnomeCanvasBpath* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GnomeCanvasBpath*       gobj()       { return reinterpret_cast<GnomeCanvasBpath*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GnomeCanvasBpath* gobj() const { return reinterpret_cast<GnomeCanvasBpath*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+private:
+
+public:
+  explicit Bpath(Group& parent);
+
+  // This property stores a pointer to GnomeCanvasPathDef
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<gpointer> property_bpath() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<gpointer> property_bpath() const;
+
+
+  void set_bpath(const Glib::RefPtr<PathDef>& path);
+
+
+};
+
+} /* namespace Canvas */
+
+} /* namespace Gnome */
+
+
+namespace Glib
+{
+  /** @relates Gnome::Canvas::Bpath
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gnome::Canvas::Bpath* wrap(GnomeCanvasBpath* object, bool take_copy = false);
+}
+#endif /* _LIBGNOMECANVASMM_BPATH_H */
+
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/canvas.cc b/libs/libgnomecanvasmm/libgnomecanvasmm/canvas.cc
new file mode 100644
index 0000000000..a02ab3e580
--- /dev/null
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/canvas.cc
@@ -0,0 +1,533 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <libgnomecanvasmm/canvas.h>
+#include <libgnomecanvasmm/private/canvas_p.h>
+
+// -*- C++ -*-
+/* $Id$ */
+
+/* canvas.cc
+ *
+ * Copyright (C) 1998 EMC Capital Management Inc.
+ * Developed by Havoc Pennington <hp@pobox.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtk.h>
+
+#include <libgnomecanvasmm/group.h>
+#include <libgnomecanvasmm/item.h>
+#include <libgnomecanvasmm/wrap_init.h>
+#include <libgnomecanvas/gnome-canvas-util.h>
+
+namespace Gnome
+{
+
+namespace Canvas
+{
+
+bool
+Canvas::get_color(const Glib::ustring& spec, Gdk::Color& color) const
+{
+  GdkColor* pColor = 0;
+  gboolean result = gnome_canvas_get_color(const_cast<GnomeCanvas*>(gobj()),
+                                           const_cast<gchar*>(spec.c_str()),
+                                           pColor);
+  color = Glib::wrap(pColor);
+  return (result == TRUE);
+}
+
+
+CanvasAA::CanvasAA()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Canvas(Glib::ConstructParams(canvas_class_.init(), "aa", TRUE, (char*) 0))
+{
+  //Note that the use of Glib::ConstructParams() here required use of _GMMPROC_PROTECTED_GCLASS in cavas.hg.
+  
+  //gtk_widget_push_colormap (gdk_rgb_get_cmap ());
+  //ObjectBase::initialize ((GObject*)g_object_new (get_type (),
+  //                                                "aa", true,
+  //                                                NULL));
+  //gtk_widget_pop_colormap();
+}
+
+CanvasAA::~CanvasAA()
+{
+}
+
+Art::AffineTrans Canvas::w2c_affine() const
+{
+  double pAffine[6];
+  gnome_canvas_w2c_affine(const_cast<GnomeCanvas*>(gobj()), pAffine);
+
+  return Art::AffineTrans(pAffine);
+}
+
+} /* namespace Canvas */
+} /* namespace Gnome */
+
+
+namespace
+{
+
+void Canvas_signal_draw_background_callback(GnomeCanvas* self, GdkDrawable* p0,gint p1,gint p2,gint p3,gint p4,void* data)
+{
+  using namespace Gnome::Canvas;
+  typedef sigc::slot< void,const Glib::RefPtr<Gdk::Drawable>&,int,int,int,int > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
+, p1
+, p2
+, p3
+, p4
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo Canvas_signal_draw_background_info =
+{
+  "draw_background",
+  (GCallback) &Canvas_signal_draw_background_callback,
+  (GCallback) &Canvas_signal_draw_background_callback
+};
+
+
+void Canvas_signal_render_background_callback(GnomeCanvas* self, GnomeCanvasBuf* p0,void* data)
+{
+  using namespace Gnome::Canvas;
+  typedef sigc::slot< void,GnomeCanvasBuf* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(p0);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo Canvas_signal_render_background_info =
+{
+  "render_background",
+  (GCallback) &Canvas_signal_render_background_callback,
+  (GCallback) &Canvas_signal_render_background_callback
+};
+
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gnome::Canvas::Canvas* wrap(GnomeCanvas* object, bool take_copy)
+{
+  return dynamic_cast<Gnome::Canvas::Canvas *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gnome
+{
+
+namespace Canvas
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& Canvas_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &Canvas_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gnome_canvas_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void Canvas_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+  klass->request_update = &request_update_vfunc_callback;
+  klass->draw_background = &draw_background_callback;
+  klass->render_background = &render_background_callback;
+}
+
+void Canvas_Class::request_update_vfunc_callback(GnomeCanvas* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->request_update_vfunc();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->request_update)
+      (*base->request_update)(self);
+  }
+}
+
+
+void Canvas_Class::draw_background_callback(GnomeCanvas* self, GdkDrawable* p0, gint p1, gint p2, gint p3, gint p4)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_draw_background(Glib::wrap(p0, true)
+, p1
+, p2
+, p3
+, p4
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->draw_background)
+      (*base->draw_background)(self, p0, p1, p2, p3, p4);
+  }
+}
+
+void Canvas_Class::render_background_callback(GnomeCanvas* self, GnomeCanvasBuf* p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_render_background(p0);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->render_background)
+      (*base->render_background)(self, p0);
+  }
+}
+
+
+Glib::ObjectBase* Canvas_Class::wrap_new(GObject* o)
+{
+  return manage(new Canvas((GnomeCanvas*)(o)));
+
+}
+
+
+/* The implementation: */
+
+Canvas::Canvas(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Layout(construct_params)
+{
+  }
+
+Canvas::Canvas(GnomeCanvas* castitem)
+:
+  Gtk::Layout((GtkLayout*)(castitem))
+{
+  }
+
+Canvas::~Canvas()
+{
+  destroy_();
+}
+
+Canvas::CppClassType Canvas::canvas_class_; // initialize static member
+
+GType Canvas::get_type()
+{
+  return canvas_class_.init().get_type();
+}
+
+GType Canvas::get_base_type()
+{
+  return gnome_canvas_get_type();
+}
+
+
+Canvas::Canvas()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Layout(Glib::ConstructParams(canvas_class_.init()))
+{
+  }
+
+Group* Canvas::root() const
+{
+  return Glib::wrap(gnome_canvas_root(const_cast<GnomeCanvas*>(gobj())));
+}
+
+void Canvas::set_scroll_region(double x1, double y1, double x2, double y2)
+{
+  gnome_canvas_set_scroll_region(gobj(), x1, y1, x2, y2);
+}
+
+void Canvas::get_scroll_region(double& x1, double& y1, double& x2, double& y2) const
+{
+  gnome_canvas_get_scroll_region(const_cast<GnomeCanvas*>(gobj()), &(x1), &(y1), &(x2), &(y2));
+}
+
+void Canvas::set_center_scroll_region(bool center)
+{
+  gnome_canvas_set_center_scroll_region(gobj(), static_cast<int>(center));
+}
+
+bool Canvas::get_center_scroll_region() const
+{
+  return gnome_canvas_get_center_scroll_region(const_cast<GnomeCanvas*>(gobj()));
+}
+
+void Canvas::set_pixels_per_unit(double n)
+{
+  gnome_canvas_set_pixels_per_unit(gobj(), n);
+}
+
+void Canvas::scroll_to(int x, int y)
+{
+  gnome_canvas_scroll_to(gobj(), x, y);
+}
+
+void Canvas::get_scroll_offsets(int& cx, int& cy) const
+{
+  gnome_canvas_get_scroll_offsets(const_cast<GnomeCanvas*>(gobj()), &cx, &cy);
+}
+
+void Canvas::update_now()
+{
+  gnome_canvas_update_now(gobj());
+}
+
+Item* Canvas::get_item_at(double x, double y) const
+{
+  return Glib::wrap(gnome_canvas_get_item_at(const_cast<GnomeCanvas*>(gobj()), x, y));
+}
+
+void Canvas::request_redraw(int x1, int y1, int x2, int y2)
+{
+  gnome_canvas_request_redraw(gobj(), x1, y1, x2, y2);
+}
+
+void Canvas::request_redraw(ArtUta* uta)
+{
+  gnome_canvas_request_redraw_uta(gobj(), uta);
+}
+
+void Canvas::w2c(double wx, double wy, int& cx, int& cy) const
+{
+  gnome_canvas_w2c(const_cast<GnomeCanvas*>(gobj()), wx, wy, &cx, &cy);
+}
+
+void Canvas::w2c(double wx, double wy, double& cx, double& cy) const
+{
+  gnome_canvas_w2c_d(const_cast<GnomeCanvas*>(gobj()), wx, wy, &(cx), &(cy));
+}
+
+void Canvas::c2w(int cx, int cy, double& wx, double& wy) const
+{
+  gnome_canvas_c2w(const_cast<GnomeCanvas*>(gobj()), cx, cy, &(wx), &(wy));
+}
+
+void Canvas::window_to_world(double winx, double winy, double& worldx, double& worldy) const
+{
+  gnome_canvas_window_to_world(const_cast<GnomeCanvas*>(gobj()), winx, winy, &(worldx), &(worldy));
+}
+
+void Canvas::world_to_window(double worldx, double worldy, double& winx, double& winy) const
+{
+  gnome_canvas_world_to_window(const_cast<GnomeCanvas*>(gobj()), worldx, worldy, &(winx), &(winy));
+}
+
+gulong Canvas::get_color_pixel(guint rgba) const
+{
+  return gnome_canvas_get_color_pixel(const_cast<GnomeCanvas*>(gobj()), rgba);
+}
+
+void Canvas::set_stipple_origin(const Glib::RefPtr<Gdk::GC>& gc)
+{
+  gnome_canvas_set_stipple_origin(gobj(), Glib::unwrap(gc));
+}
+
+void Canvas::set_dither(Gdk::RgbDither dither)
+{
+  gnome_canvas_set_dither(gobj(), ((GdkRgbDither)(dither)));
+}
+
+Gdk::RgbDither Canvas::get_dither() const
+{
+  return ((Gdk::RgbDither)(gnome_canvas_get_dither(const_cast<GnomeCanvas*>(gobj()))));
+}
+
+void Canvas::update_svp(ArtSVP** p_svp, ArtSVP* new_svp)
+{
+  gnome_canvas_update_svp(gobj(), p_svp, new_svp);
+}
+
+void Canvas::update_svp_clip(ArtSVP** p_svp, ArtSVP* new_svp, ArtSVP* clip_svp)
+{
+  gnome_canvas_update_svp_clip(gobj(), p_svp, new_svp, clip_svp);
+}
+
+double Canvas::get_pixels_per_unit() const
+{
+  return gobj()->pixels_per_unit;
+}
+
+
+Glib::SignalProxy5< void,const Glib::RefPtr<Gdk::Drawable>&,int,int,int,int > Canvas::signal_draw_background()
+{
+  return Glib::SignalProxy5< void,const Glib::RefPtr<Gdk::Drawable>&,int,int,int,int >(this, &Canvas_signal_draw_background_info);
+}
+
+Glib::SignalProxy1< void,GnomeCanvasBuf* > Canvas::signal_render_background()
+{
+  return Glib::SignalProxy1< void,GnomeCanvasBuf* >(this, &Canvas_signal_render_background_info);
+}
+
+
+Glib::PropertyProxy<bool> Canvas::property_aa() 
+{
+  return Glib::PropertyProxy<bool>(this, "aa");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Canvas::property_aa() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "aa");
+}
+
+
+void Gnome::Canvas::Canvas::on_draw_background(const Glib::RefPtr<Gdk::Drawable>& drawable, int x, int y, int width, int height)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->draw_background)
+    (*base->draw_background)(gobj(),Glib::unwrap(drawable),x,y,width,height);
+}
+
+void Gnome::Canvas::Canvas::on_render_background(GnomeCanvasBuf* buf)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->render_background)
+    (*base->render_background)(gobj(),buf);
+}
+
+
+void Gnome::Canvas::Canvas::request_update_vfunc() 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->request_update)
+    (*base->request_update)(gobj());
+}
+
+
+} // namespace Canvas
+
+} // namespace Gnome
+
+
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/canvas.h b/libs/libgnomecanvasmm/libgnomecanvasmm/canvas.h
new file mode 100644
index 0000000000..c7ee6e8d71
--- /dev/null
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/canvas.h
@@ -0,0 +1,443 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _LIBGNOMECANVASMM_CANVAS_H
+#define _LIBGNOMECANVASMM_CANVAS_H
+
+#include <glibmm.h>
+
+// -*- C++ -*-
+/* $Id$ */
+
+/* canvas.h
+ * 
+ * Copyright (C) 1998 EMC Capital Management Inc.
+ * Developed by Havoc Pennington <hp@pobox.com>
+ *
+ * Copyright (C) 1999 The Gtk-- Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <libgnomecanvas/gnome-canvas.h>
+#include <libgnomecanvasmm/affinetrans.h>
+#include <gtkmm/layout.h>
+#include <gdkmm/color.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GnomeCanvas GnomeCanvas;
+typedef struct _GnomeCanvasClass GnomeCanvasClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gnome
+{
+
+namespace Canvas
+{ class Canvas_Class; } // namespace Canvas
+
+} // namespace Gnome
+namespace Gnome
+{
+
+namespace Canvas
+{
+
+class Item;
+class Group;
+
+/** Canvas functions usually operate in either World coordinates
+ * (units for the entire canvas), or Canvas coordinates (pixels starting 
+ * at 0,0 in the top left).  There are functions to transform from 
+ * one to the other.
+ */
+
+class Canvas : public Gtk::Layout
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Canvas CppObjectType;
+  typedef Canvas_Class CppClassType;
+  typedef GnomeCanvas BaseObjectType;
+  typedef GnomeCanvasClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~Canvas();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+protected:
+  friend class Canvas_Class;
+  static CppClassType canvas_class_;
+
+  // noncopyable
+  Canvas(const Canvas&);
+  Canvas& operator=(const Canvas&);
+
+protected:
+  explicit Canvas(const Glib::ConstructParams& construct_params);
+  explicit Canvas(GnomeCanvas* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GnomeCanvas*       gobj()       { return reinterpret_cast<GnomeCanvas*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GnomeCanvas* gobj() const { return reinterpret_cast<GnomeCanvas*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+  virtual void on_draw_background(const Glib::RefPtr<Gdk::Drawable>& drawable, int x, int y, int width, int height);
+  virtual void on_render_background(GnomeCanvasBuf* buf);
+
+
+private:
+;
+public:
+  Canvas();
+
+  //Allow CanvasAA to access the canvas_class_ member.
+  
+
+  //: Get the root canvas item
+  
+  /** Queries the root group of a canvas.
+   * @return The root group of the specified canvas.
+   */
+  Group* root() const;
+           
+  //: Limits of scroll region
+  
+  /** Sets the scrolling region of a canvas to the specified rectangle.  The canvas
+   * will then be able to scroll only within this region.  The view of the canvas
+   * is adjusted as appropriate to display as much of the new region as possible.
+   * @param x1 Leftmost limit of the scrolling region.
+   * @param y1 Upper limit of the scrolling region.
+   * @param x2 Rightmost limit of the scrolling region.
+   * @param y2 Lower limit of the scrolling region.
+   */
+  void set_scroll_region(double x1, double y1, double x2, double y2);
+
+  //: Get limits of scroll region
+  
+  /** Queries the scrolling region of a canvas.
+   * @param x1 Leftmost limit of the scrolling region (return value).
+   * @param y1 Upper limit of the scrolling region (return value).
+   * @param x2 Rightmost limit of the scrolling region (return value).
+   * @param y2 Lower limit of the scrolling region (return value).
+   */
+  void get_scroll_region(double& x1, double& y1, double& x2, double& y2) const;
+
+  
+  /** When the scrolling region of the canvas is smaller than the canvas window,
+   * e.g.\  the allocation of the canvas, it can be either centered on the window
+   * or simply made to be on the upper-left corner on the window.  This function
+   * lets you configure this property.
+   * @param center_scroll_region Whether to center the scrolling region in the canvas
+   * window when it is smaller than the canvas' allocation.
+   */
+  void set_center_scroll_region(bool center);
+
+  
+  /** Returns whether the canvas is set to center the scrolling region in the window
+   * if the former is smaller than the canvas' allocation.
+   * @return Whether the scroll region is being centered in the canvas window.
+   */
+  bool get_center_scroll_region() const;
+
+  //: Set the pixels/world coordinates ratio
+  //- With no arguments sets to default of 1.0.
+  
+  /** Sets the zooming factor of a canvas by specifying the number of pixels that
+   * correspond to one canvas unit.
+   * 
+   * The anchor point for zooming, i.e. the point that stays fixed and all others
+   * zoom inwards or outwards from it, depends on whether the canvas is set to
+   * center the scrolling region or not.  You can control this using the
+   * set_center_scroll_region() function.  If the canvas is set to
+   * center the scroll region, then the center of the canvas window is used as the
+   * anchor point for zooming.  Otherwise, the upper-left corner of the canvas
+   * window is used as the anchor point.
+   * @param n The number of pixels that correspond to one canvas unit.
+   */
+  void set_pixels_per_unit(double n = 1.0);
+
+  //: Shift window.
+  //- Makes a canvas scroll to the specified offsets, given in canvas pixel
+  //- units.
+  //- The canvas will adjust the view so that it is not outside the scrolling
+  //- region.  This function is typically not used, as it is better to hook
+  //- scrollbars to the canvas layout's scrolling adjusments.
+  
+  /** Makes a canvas scroll to the specified offsets, given in canvas pixel units.
+   * The canvas will adjust the view so that it is not outside the scrolling
+   * region.  This function is typically not used, as it is better to hook
+   * scrollbars to the canvas layout's scrolling adjusments.
+   * @param cx Horizontal scrolling offset in canvas pixel units.
+   * @param cy Vertical scrolling offset in canvas pixel units.
+   */
+  void scroll_to(int x, int y);
+
+  //: Scroll offsets in canvas pixel coordinates.
+  
+  /** Queries the scrolling offsets of a canvas.  The values are returned in canvas
+   * pixel units.
+   * @param cx Horizontal scrolling offset (return value).
+   * @param cy Vertical scrolling offset (return value).
+   */
+  void get_scroll_offsets(int& cx, int& cy) const;
+
+  //: Repaint immediately, don't wait for idle loop
+  //- normally the canvas queues repainting and does it in an
+  //- idle loop
+  
+  /** Forces an immediate update and redraw of a canvas.  If the canvas does not
+   * have any pending update or redraw requests, then no action is taken.  This is
+   * typically only used by applications that need explicit control of when the
+   * display is updated, like games.  It is not needed by normal applications.
+   */
+  void update_now();
+
+  //: Find an item at a location.
+  //- Looks for the item that is under the specified position, which must be
+  //- specified in world coordinates.  Arguments are in world coordinates.
+  //- Returns 0 if no item is at that
+  //- location.
+  
+  /** Looks for the item that is under the specified position, which must be
+   * specified in world coordinates.
+   * @param x X position in world coordinates.
+   * @param y Y position in world coordinates.
+   * @return The sought item, or <tt>0</tt> if no item is at the specified
+   * coordinates.
+   */
+  Item* get_item_at(double x, double y) const;
+
+
+  //: Repaint small area (internal)
+  //- Used only by item implementations. Request an eventual redraw
+  //- of the region, which includes x1,y1 but not x2,y2
+  
+  /** Convenience function that informs a canvas that the specified rectangle needs
+   * to be repainted.  This function converts the rectangle to a microtile array
+   * and feeds it to request_redraw_uta().  The rectangle includes
+   *  @a x1  and @a y1 , but not @a x2  and @a y2 .  To be used only by item implementations.
+   * @param x1 Leftmost coordinate of the rectangle to be redrawn.
+   * @param y1 Upper coordinate of the rectangle to be redrawn.
+   * @param x2 Rightmost coordinate of the rectangle to be redrawn, plus 1.
+   * @param y2 Lower coordinate of the rectangle to be redrawn, plus 1.
+   */
+  void request_redraw(int x1, int y1, int x2, int y2);
+  //TODO: Investigate ArtUta.
+  
+  /** Informs a canvas that the specified area, given as a microtile array, needs
+   * to be repainted.  To be used only by item implementations.
+   * @param uta Microtile array that specifies the area to be redrawn.  It will
+   * be freed by this function, so the argument you pass will be invalid
+   * after you call this function.
+   */
+  void request_redraw(ArtUta* uta);
+
+  Art::AffineTrans w2c_affine() const;
+  
+
+  //: Convert from World to canvas coordinates (units for the entire canvas)
+  //: to Canvas coordinates (pixels starting at 0,0 in the top left
+  //: of the visible area). The relationship depends on the current
+  //: scroll position and the pixels_per_unit ratio (zoom factor)
+  
+  /** Converts world coordinates into canvas pixel coordinates.
+   * @param wx World X coordinate.
+   * @param wy World Y coordinate.
+   * @param cx X pixel coordinate (return value).
+   * @param cy Y pixel coordinate (return value).
+   */
+  void w2c(double wx, double wy, int& cx, int& cy) const;
+  
+  /** Converts world coordinates into canvas pixel coordinates.  This version
+   * @param wx World X coordinate.
+   * @param wy World Y coordinate.
+   * @param cx X pixel coordinate (return value).
+   * @param cy Y pixel coordinate (return value).
+   * @return Coordinates in floating point coordinates, for greater precision.
+   */
+  void w2c(double wx, double wy, double& cx, double& cy) const;
+
+  //: From Canvas to World
+  
+  /** Converts canvas pixel coordinates to world coordinates.
+   * @param cx Canvas pixel X coordinate.
+   * @param cy Canvas pixel Y coordinate.
+   * @param wx X world coordinate (return value).
+   * @param wy Y world coordinate (return value).
+   */
+  void c2w(int cx, int cy, double& wx, double& wy) const;
+
+  //: Convert from Window coordinates to world coordinates.
+  //- Window coordinates are based of the widget's GdkWindow.
+  //- This is fairly low-level and not generally useful.
+  
+  /** Converts window-relative coordinates into world coordinates.  You can use
+   * this when you need to convert mouse coordinates into world coordinates, for
+   * example.
+   * @param winx Window-relative X coordinate.
+   * @param winy Window-relative Y coordinate.
+   * @param worldx X world coordinate (return value).
+   * @param worldy Y world coordinate (return value).
+   */
+  void window_to_world (double winx,double winy, double& worldx,double& worldy) const;
+
+  //: Convert from world coordinates to Window coordinates.
+  //- Window coordinates are based of the widget's GdkWindow.
+  //- This is fairly low-level and not generally useful.
+  
+  /** Converts world coordinates into window-relative coordinates.
+   * @param worldx World X coordinate.
+   * @param worldy World Y coordinate.
+   * @param winx X window-relative coordinate.
+   * @param winy Y window-relative coordinate.
+   */
+  void world_to_window (double worldx, double worldy, double& winx, double& winy) const;
+
+  //: Parse color spec string and allocate it into the GdkColor.
+  bool get_color(const Glib::ustring& spec, Gdk::Color& color) const;
+  
+
+/* Allocates a color from the RGB value passed into this function. */
+  
+  /** Allocates a color from the RGBA value passed into this function.  The alpha
+   * opacity value is discarded, since normal X colors do not support it.
+   * @param rgba RGBA color specification.
+   * @return Allocated pixel value corresponding to the specified color.
+   */
+  gulong get_color_pixel(guint rgba) const;
+  
+  /** Sets the stipple origin of the specified GC as is appropriate for the canvas,
+   * so that it will be aligned with other stipple patterns used by canvas items.
+   * This is typically only needed by item implementations.
+   * @param gc GC on which to set the stipple origin.
+   */
+  void set_stipple_origin(const Glib::RefPtr<Gdk::GC>& gc);
+  
+  /** Controls dithered rendering for antialiased canvases. The value of
+   * dither should be Gdk::RGB_DITHER_NONE, Gdk::RGB_DITHER_NORMAL, or
+   * Gdk::RGB_DITHER_MAX. The default canvas setting is
+   * Gdk::RGB_DITHER_NORMAL.
+   * @param dither Type of dithering used to render an antialiased canvas.
+   */
+  void set_dither(Gdk::RgbDither dither);
+  
+  /** Returns the type of dithering used to render an antialiased canvas.
+   * @return The dither setting.
+   */
+  Gdk::RgbDither get_dither() const;
+
+
+  //TODO: Look at ArtSVP.
+  
+  /** Sets the svp to the new value, requesting repaint on what's changed. This
+   * function takes responsibility for freeing new_svp.
+   * @param p_svp A pointer to the existing svp.
+   * @param new_svp The new svp.
+   */
+  void update_svp(ArtSVP** p_svp, ArtSVP* new_svp);
+  
+  /** Sets the svp to the new value, clipping if necessary, and requesting repaint
+   * on what's changed. This function takes responsibility for freeing new_svp.
+   * @param p_svp A pointer to the existing svp.
+   * @param new_svp The new svp.
+   * @param clip_svp A clip path, if non-null.
+   */
+  void update_svp_clip(ArtSVP** p_svp, ArtSVP* new_svp, ArtSVP* clip_svp);
+
+  // The following are simply accessed via the struct in C,
+  //  but Federico reports that they are meant to be used.
+  //: Get the pixels per unit.
+  double get_pixels_per_unit() const;
+
+  //: Draw the background for the area given.
+  //- This method is only used for non-antialiased canvases.
+  
+
+  Glib::SignalProxy5< void,const Glib::RefPtr<Gdk::Drawable>&,int,int,int,int > signal_draw_background();
+
+  // Render the background for the buffer given. 
+  //- The buf data structure contains both a pointer to a packed 24-bit
+  //- RGB array, and the coordinates.
+  //- This method is only used for antialiased canvases.
+  
+
+  Glib::SignalProxy1< void,GnomeCanvasBuf* > signal_render_background();
+
+  //: Private Virtual methods for groping the canvas inside bonobo.
+    virtual void request_update_vfunc();
+
+  // Whether the canvas is in antialiased mode or not.
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_aa() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_aa() const;
+
+
+};
+
+//: Antialiased Canvas.
+//- Constructor takes care of push/pop actions of the colormap.
+class CanvasAA : public Canvas
+{
+  public:
+    CanvasAA();
+    virtual ~CanvasAA();
+};
+
+} /* namespace Canvas */
+} /* namespace Gnome */
+
+
+namespace Glib
+{
+  /** @relates Gnome::Canvas::Canvas
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gnome::Canvas::Canvas* wrap(GnomeCanvas* object, bool take_copy = false);
+}
+#endif /* _LIBGNOMECANVASMM_CANVAS_H */
+
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/ellipse.cc b/libs/libgnomecanvasmm/libgnomecanvasmm/ellipse.cc
new file mode 100644
index 0000000000..ecc2402516
--- /dev/null
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/ellipse.cc
@@ -0,0 +1,147 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <libgnomecanvasmm/ellipse.h>
+#include <libgnomecanvasmm/private/ellipse_p.h>
+
+// -*- C++ -*-
+/* $Id$ */
+
+/* ellipse.cc
+ *
+ * Copyright (C) 1998 EMC Capital Management Inc.
+ * Developed by Havoc Pennington <hp@pobox.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+namespace Gnome
+{
+
+namespace Canvas
+{
+
+Ellipse::Ellipse(Group& parentx, double x1, double y1, double x2, double y2)
+ : RectEllipse(GNOME_CANVAS_RE(g_object_new(get_type(), 0)))
+{
+  item_construct(parentx);
+  set("x1",x1,"y1",y1,"x2",x2,"y2",y2,0);
+}
+
+Ellipse::Ellipse(Group& parentx)
+  : RectEllipse(GNOME_CANVAS_RE(g_object_new(get_type(), 0)))
+{
+  item_construct(parentx);
+}
+
+} /* namespace Canvas */
+} /* namespace Gnome */
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gnome::Canvas::Ellipse* wrap(GnomeCanvasEllipse* object, bool take_copy)
+{
+  return dynamic_cast<Gnome::Canvas::Ellipse *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gnome
+{
+
+namespace Canvas
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& Ellipse_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &Ellipse_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gnome_canvas_ellipse_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void Ellipse_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* Ellipse_Class::wrap_new(GObject* o)
+{
+  return manage(new Ellipse((GnomeCanvasEllipse*)(o)));
+
+}
+
+
+/* The implementation: */
+
+Ellipse::Ellipse(const Glib::ConstructParams& construct_params)
+:
+  RectEllipse(construct_params)
+{
+  }
+
+Ellipse::Ellipse(GnomeCanvasEllipse* castitem)
+:
+  RectEllipse((GnomeCanvasRE*)(castitem))
+{
+  }
+
+Ellipse::~Ellipse()
+{
+  destroy_();
+}
+
+Ellipse::CppClassType Ellipse::ellipse_class_; // initialize static member
+
+GType Ellipse::get_type()
+{
+  return ellipse_class_.init().get_type();
+}
+
+GType Ellipse::get_base_type()
+{
+  return gnome_canvas_ellipse_get_type();
+}
+
+
+} // namespace Canvas
+
+} // namespace Gnome
+
+
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/ellipse.h b/libs/libgnomecanvasmm/libgnomecanvasmm/ellipse.h
new file mode 100644
index 0000000000..e085dc45e8
--- /dev/null
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/ellipse.h
@@ -0,0 +1,130 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _LIBGNOMECANVASMM_ELLIPSE_H
+#define _LIBGNOMECANVASMM_ELLIPSE_H
+
+#include <glibmm.h>
+
+// -*- C++ -*-
+/* $Id$ */
+
+/* ellipse.h
+ * 
+ * Copyright (C) 1998 EMC Capital Management Inc.
+ * Developed by Havoc Pennington <hp@pobox.com>
+ *
+ * Copyright (C) 1999 The Gtk-- Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <libgnomecanvasmm/item.h>
+#include <libgnomecanvasmm/group.h>
+#include <libgnomecanvasmm/rect-ellipse.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GnomeCanvasEllipse GnomeCanvasEllipse;
+typedef struct _GnomeCanvasEllipseClass GnomeCanvasEllipseClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gnome
+{
+
+namespace Canvas
+{ class Ellipse_Class; } // namespace Canvas
+
+} // namespace Gnome
+namespace Gnome
+{
+
+namespace Canvas
+{
+
+
+class Ellipse : public RectEllipse
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Ellipse CppObjectType;
+  typedef Ellipse_Class CppClassType;
+  typedef GnomeCanvasEllipse BaseObjectType;
+  typedef GnomeCanvasEllipseClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~Ellipse();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class Ellipse_Class;
+  static CppClassType ellipse_class_;
+
+  // noncopyable
+  Ellipse(const Ellipse&);
+  Ellipse& operator=(const Ellipse&);
+
+protected:
+  explicit Ellipse(const Glib::ConstructParams& construct_params);
+  explicit Ellipse(GnomeCanvasEllipse* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GnomeCanvasEllipse*       gobj()       { return reinterpret_cast<GnomeCanvasEllipse*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GnomeCanvasEllipse* gobj() const { return reinterpret_cast<GnomeCanvasEllipse*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+private:
+;
+
+public:
+  explicit Ellipse(Group& parent);
+  Ellipse(Group& parent, double x1, double y1, double x2, double y2);
+
+
+};
+
+} /* namespace Canvas */
+} /* namespace Gnome */
+namespace Glib
+{
+  /** @relates Gnome::Canvas::Ellipse
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gnome::Canvas::Ellipse* wrap(GnomeCanvasEllipse* object, bool take_copy = false);
+}
+#endif /* _LIBGNOMECANVASMM_ELLIPSE_H */
+
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/group.cc b/libs/libgnomecanvasmm/libgnomecanvasmm/group.cc
new file mode 100644
index 0000000000..90c9c97466
--- /dev/null
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/group.cc
@@ -0,0 +1,170 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <libgnomecanvasmm/group.h>
+#include <libgnomecanvasmm/private/group_p.h>
+
+// -*- C++ -*-
+/* $Id$ */
+
+/* group.cc
+ *
+ * Copyright (C) 1998 EMC Capital Management Inc.
+ * Developed by Havoc Pennington <hp@pobox.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+namespace Gnome
+{
+
+namespace Canvas
+{
+
+Group::Group(Group& parentx, double x, double y)
+  : Item(GNOME_CANVAS_ITEM(g_object_new(get_type(), 0)))
+{
+  item_construct(parentx);
+  set("x", x, "y", y, 0);
+}
+
+} /* namespace Canvas */
+} /* namespace Gnome */
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gnome::Canvas::Group* wrap(GnomeCanvasGroup* object, bool take_copy)
+{
+  return dynamic_cast<Gnome::Canvas::Group *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gnome
+{
+
+namespace Canvas
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& Group_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &Group_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gnome_canvas_group_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void Group_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* Group_Class::wrap_new(GObject* o)
+{
+  return manage(new Group((GnomeCanvasGroup*)(o)));
+
+}
+
+
+/* The implementation: */
+
+Group::Group(const Glib::ConstructParams& construct_params)
+:
+  Item(construct_params)
+{
+  }
+
+Group::Group(GnomeCanvasGroup* castitem)
+:
+  Item((GnomeCanvasItem*)(castitem))
+{
+  }
+
+Group::~Group()
+{
+  destroy_();
+}
+
+Group::CppClassType Group::group_class_; // initialize static member
+
+GType Group::get_type()
+{
+  return group_class_.init().get_type();
+}
+
+GType Group::get_base_type()
+{
+  return gnome_canvas_group_get_type();
+}
+
+
+Group::Group()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Item(Glib::ConstructParams(group_class_.init()))
+{
+  }
+
+
+Glib::PropertyProxy<double> Group::property_x() 
+{
+  return Glib::PropertyProxy<double>(this, "x");
+}
+
+Glib::PropertyProxy_ReadOnly<double> Group::property_x() const
+{
+  return Glib::PropertyProxy_ReadOnly<double>(this, "x");
+}
+
+Glib::PropertyProxy<double> Group::property_y() 
+{
+  return Glib::PropertyProxy<double>(this, "y");
+}
+
+Glib::PropertyProxy_ReadOnly<double> Group::property_y() const
+{
+  return Glib::PropertyProxy_ReadOnly<double>(this, "y");
+}
+
+
+} // namespace Canvas
+
+} // namespace Gnome
+
+
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/group.h b/libs/libgnomecanvasmm/libgnomecanvasmm/group.h
new file mode 100644
index 0000000000..ef359297dd
--- /dev/null
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/group.h
@@ -0,0 +1,164 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _LIBGNOMECANVASMM_GROUP_H
+#define _LIBGNOMECANVASMM_GROUP_H
+
+#include <glibmm.h>
+
+// -*- C++ -*-
+/* $Id$ */
+
+/* group.h
+ * 
+ * Copyright (C) 1998 EMC Capital Management Inc.
+ * Developed by Havoc Pennington <hp@pobox.com>
+ *
+ * Copyright (C) 1999 The Gtk-- Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <libgnomecanvasmm/item.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GnomeCanvasGroup GnomeCanvasGroup;
+typedef struct _GnomeCanvasGroupClass GnomeCanvasGroupClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gnome
+{
+
+namespace Canvas
+{ class Group_Class; } // namespace Canvas
+
+} // namespace Gnome
+namespace Gnome
+{
+
+namespace Canvas
+{
+
+class Canvas;
+
+
+class Group : public Item
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Group CppObjectType;
+  typedef Group_Class CppClassType;
+  typedef GnomeCanvasGroup BaseObjectType;
+  typedef GnomeCanvasGroupClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~Group();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class Group_Class;
+  static CppClassType group_class_;
+
+  // noncopyable
+  Group(const Group&);
+  Group& operator=(const Group&);
+
+protected:
+  explicit Group(const Glib::ConstructParams& construct_params);
+  explicit Group(GnomeCanvasGroup* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GnomeCanvasGroup*       gobj()       { return reinterpret_cast<GnomeCanvasGroup*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GnomeCanvasGroup* gobj() const { return reinterpret_cast<GnomeCanvasGroup*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+private:
+;
+public:
+  friend class Canvas;
+  explicit Group(Group& parent, double x = 0, double y = 0);
+  Group();
+
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<double> property_x() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<double> property_x() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<double> property_y() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<double> property_y() const;
+
+
+};
+
+} /* namespace Canvas */
+} /* namespace Gnome */
+
+namespace Glib
+{
+  /** @relates Gnome::Canvas::Group
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gnome::Canvas::Group* wrap(GnomeCanvasGroup* object, bool take_copy = false);
+}
+#endif /* _LIBGNOMECANVASMM_GROUP_H */
+
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/init.cc b/libs/libgnomecanvasmm/libgnomecanvasmm/init.cc
new file mode 100644
index 0000000000..dfc47613ad
--- /dev/null
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/init.cc
@@ -0,0 +1,37 @@
+/* init.cc
+ *
+ * Copyright (C) 2001 The libgnomeuimm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <libgnomecanvasmm/init.h>
+#include <gtkmm/main.h>
+#include <libgnomecanvasmm/wrap_init.h>
+
+namespace Gnome
+{
+
+namespace Canvas
+{
+
+void init()
+{
+  Gtk::Main::init_gtkmm_internals(); //Sets up the g type system and the Glib::wrap() table.
+  wrap_init(); //Tells the Glib::wrap() table about the libgnomecanvasmm classes.
+}
+
+} /* namespace Canvas */
+} /* namespace Gnome */
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/init.h b/libs/libgnomecanvasmm/libgnomecanvasmm/init.h
new file mode 100644
index 0000000000..c915c918cf
--- /dev/null
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/init.h
@@ -0,0 +1,37 @@
+#ifndef _LIBGNOMEUIMM_INIT_H
+#define _LIBGNOMEUIMM_INIT_H
+
+/* init.h
+ *
+ * Copyright (C) 2001 The libgnomeuimm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+namespace Gnome
+{
+
+namespace Canvas
+{
+
+/* Initialize libgnomecanvas wrap table:
+ * You still need a Gtk::Main instance, or a subclass such as Gnome::Main.
+ */
+void init();
+
+} /* namespace Canvas */
+} /* namespace Gnome */
+
+#endif // _LIBGNOMEUIMM_INIT_H
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/item.cc b/libs/libgnomecanvasmm/libgnomecanvasmm/item.cc
new file mode 100644
index 0000000000..b39c34ad89
--- /dev/null
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/item.cc
@@ -0,0 +1,908 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <libgnomecanvasmm/item.h>
+#include <libgnomecanvasmm/private/item_p.h>
+
+// -*- C++ -*-
+/* $Id$ */
+
+/* item.cc
+ *
+ * Copyright (C) 1998 EMC Capital Management Inc.
+ * Developed by Havoc Pennington <hp@pobox.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+extern "C" 
+{
+#include <stdarg.h>
+}
+
+#include <libgnomecanvasmm/canvas.h>
+#include <libgnomecanvasmm/group.h>
+#include <libgnomecanvas/gnome-canvas-util.h>
+
+namespace Gnome
+{
+
+namespace Canvas
+{
+
+//This function creates an empty va_list instead of just passing 0 to gnome_canvas_item_construct().
+//This is necessary on the alpha platform.
+//It needs to be a separate helper function because we need a ... argument. 
+static void
+item_construct_helper(GnomeCanvasItem *item, GnomeCanvasGroup *group, ...)
+{
+  va_list va;
+  va_start(va, group);
+  gnome_canvas_item_construct(item, group, 0, va);
+  va_end(va);
+}
+
+void
+Item::item_construct(Group& group)
+{
+  item_construct_helper(GNOME_CANVAS_ITEM(gobj()), group.gobj()); //With no ... arguments.
+}
+
+void
+Item::item_construct(Group& group, const gchar* first_arg_name,
+                                 va_list ap)
+{
+  gnome_canvas_item_construct(GNOME_CANVAS_ITEM(gobj()), group.gobj(),
+                              first_arg_name,
+                              ap);
+}
+
+void 
+Item::set(const gchar* first_arg_name, ...)
+{
+  va_list args;
+  va_start(args,first_arg_name);
+  gnome_canvas_item_set_valist(gobj(), first_arg_name, args);
+  va_end(args);
+}
+
+int Item::grab(unsigned int event_mask, const Gdk::Cursor& cursor, guint32 etime)
+{
+  return gnome_canvas_item_grab(gobj(), event_mask, const_cast<GdkCursor*>(cursor.gobj()), etime);
+}
+
+int Item::grab(unsigned int event_mask, guint32 etime)
+{
+  return gnome_canvas_item_grab(gobj(), event_mask, 0, etime);
+}
+
+void
+Item::affine_relative(const Art::AffineTrans &affine)
+{
+  gnome_canvas_item_affine_relative (gobj(), affine.gobj());
+}
+
+void
+Item::affine_absolute (const Art::AffineTrans &affine)
+{
+  gnome_canvas_item_affine_absolute (gobj(), affine.gobj());
+}
+
+Art::AffineTrans
+Item::get_i2w_affine() const
+{
+  double tmp[6] = {0};
+  
+  gnome_canvas_item_i2w_affine(const_cast<GnomeCanvasItem*>(gobj()), tmp);
+  return Art::AffineTrans(tmp);
+}
+
+Art::AffineTrans
+Item::get_i2c_affine() const
+{
+  double tmp[6] = {0};
+  
+  gnome_canvas_item_i2c_affine(const_cast<GnomeCanvasItem*>(gobj()), tmp);
+  return Art::AffineTrans(tmp);
+}
+
+} /* namespace Canvas */
+} /* namespace Gnome */
+
+
+namespace
+{
+
+gboolean Item_signal_event_callback(GnomeCanvasItem* self, GdkEvent* p0,void* data)
+{
+  using namespace Gnome::Canvas;
+  typedef sigc::slot< bool,GdkEvent* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean Item_signal_event_notify_callback(GnomeCanvasItem* self, GdkEvent* p0, void* data)
+{
+  using namespace Gnome::Canvas;
+  typedef sigc::slot< void,GdkEvent* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(p0);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+const Glib::SignalProxyInfo Item_signal_event_info =
+{
+  "event",
+  (GCallback) &Item_signal_event_callback,
+  (GCallback) &Item_signal_event_notify_callback
+};
+
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gnome::Canvas::Item* wrap(GnomeCanvasItem* object, bool take_copy)
+{
+  return dynamic_cast<Gnome::Canvas::Item *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gnome
+{
+
+namespace Canvas
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& Item_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &Item_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gnome_canvas_item_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void Item_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+  klass->update = &update_vfunc_callback;
+  klass->realize = &realize_vfunc_callback;
+  klass->unrealize = &unrealize_vfunc_callback;
+  klass->map = &map_vfunc_callback;
+  klass->unmap = &unmap_vfunc_callback;
+  klass->coverage = &coverage_vfunc_callback;
+  klass->draw = &draw_vfunc_callback;
+  klass->render = &render_vfunc_callback;
+  klass->point = &point_vfunc_callback;
+  klass->bounds = &bounds_vfunc_callback;
+  klass->event = &event_callback;
+}
+
+void Item_Class::update_vfunc_callback(GnomeCanvasItem* self, double* affine, ArtSVP* clip_path, int flags)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->update_vfunc(affine, clip_path, flags);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->update)
+      (*base->update)(self, affine, clip_path, flags);
+  }
+}
+
+void Item_Class::realize_vfunc_callback(GnomeCanvasItem* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->realize_vfunc();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->realize)
+      (*base->realize)(self);
+  }
+}
+
+void Item_Class::unrealize_vfunc_callback(GnomeCanvasItem* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->unrealize_vfunc();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->unrealize)
+      (*base->unrealize)(self);
+  }
+}
+
+void Item_Class::map_vfunc_callback(GnomeCanvasItem* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->map_vfunc();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->map)
+      (*base->map)(self);
+  }
+}
+
+void Item_Class::unmap_vfunc_callback(GnomeCanvasItem* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->unmap_vfunc();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->unmap)
+      (*base->unmap)(self);
+  }
+}
+
+ArtUta* Item_Class::coverage_vfunc_callback(GnomeCanvasItem* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return obj->coverage_vfunc();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->coverage)
+      return (*base->coverage)(self);
+  }
+
+  typedef ArtUta* RType;
+  return RType();
+}
+
+void Item_Class::draw_vfunc_callback(GnomeCanvasItem* self, GdkDrawable* drawable, int x, int y, int width, int height)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->draw_vfunc(Glib::wrap(drawable, true)
+, x, y, width, height);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->draw)
+      (*base->draw)(self, drawable, x, y, width, height);
+  }
+}
+
+void Item_Class::render_vfunc_callback(GnomeCanvasItem* self, GnomeCanvasBuf* buf)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->render_vfunc(buf);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->render)
+      (*base->render)(self, buf);
+  }
+}
+
+double Item_Class::point_vfunc_callback(GnomeCanvasItem* self, double x, double y, int cx, int cy, GnomeCanvasItem** actual_item)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return obj->point_vfunc(x, y, cx, cy, actual_item);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->point)
+      return (*base->point)(self, x, y, cx, cy, actual_item);
+  }
+
+  typedef double RType;
+  return RType();
+}
+
+void Item_Class::bounds_vfunc_callback(GnomeCanvasItem* self, double* x1, double* y1, double* x2, double* y2)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->bounds_vfunc(x1, y1, x2, y2);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->bounds)
+      (*base->bounds)(self, x1, y1, x2, y2);
+  }
+}
+
+
+gboolean Item_Class::event_callback(GnomeCanvasItem* self, GdkEvent* p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return static_cast<int>(obj->on_event(p0));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->event)
+      return (*base->event)(self, p0);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+
+Glib::ObjectBase* Item_Class::wrap_new(GObject* o)
+{
+  return manage(new Item((GnomeCanvasItem*)(o)));
+
+}
+
+
+/* The implementation: */
+
+Item::Item(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Object(construct_params)
+{
+  }
+
+Item::Item(GnomeCanvasItem* castitem)
+:
+  Gtk::Object((GtkObject*)(castitem))
+{
+  }
+
+Item::~Item()
+{
+  destroy_();
+}
+
+Item::CppClassType Item::item_class_; // initialize static member
+
+GType Item::get_type()
+{
+  return item_class_.init().get_type();
+}
+
+GType Item::get_base_type()
+{
+  return gnome_canvas_item_get_type();
+}
+
+
+void Item::move(double dx, double dy)
+{
+  gnome_canvas_item_move(gobj(), dx, dy);
+}
+
+void Item::raise(int positions)
+{
+  gnome_canvas_item_raise(gobj(), positions);
+}
+
+void Item::lower(int positions)
+{
+  gnome_canvas_item_lower(gobj(), positions);
+}
+
+void Item::raise_to_top()
+{
+  gnome_canvas_item_raise_to_top(gobj());
+}
+
+void Item::lower_to_bottom()
+{
+  gnome_canvas_item_lower_to_bottom(gobj());
+}
+
+void Item::ungrab(guint32 etime)
+{
+  gnome_canvas_item_ungrab(gobj(), etime);
+}
+
+void Item::w2i(double& x, double& y)
+{
+  gnome_canvas_item_w2i(gobj(), &(x), &(y));
+}
+
+void Item::i2w(double& x, double& y)
+{
+  gnome_canvas_item_i2w(gobj(), &(x), &(y));
+}
+
+void Item::grab_focus()
+{
+  gnome_canvas_item_grab_focus(gobj());
+}
+
+void Item::get_bounds(double& x1, double& y1, double& x2, double& y2) const
+{
+  gnome_canvas_item_get_bounds(const_cast<GnomeCanvasItem*>(gobj()), &(x1), &(y1), &(x2), &(y2));
+}
+
+void Item::show()
+{
+  gnome_canvas_item_show(gobj());
+}
+
+void Item::hide()
+{
+  gnome_canvas_item_hide(gobj());
+}
+
+void Item::reparent(Group& new_group)
+{
+  gnome_canvas_item_reparent(gobj(), (new_group).gobj());
+}
+
+Canvas* Item::get_canvas() const
+{
+  return Glib::wrap(gobj()->canvas);
+}
+
+void Item::request_update()
+{
+  gnome_canvas_item_request_update(gobj());
+}
+
+void Item::reset_bounds()
+{
+  gnome_canvas_item_reset_bounds(gobj());
+}
+
+void Item::update_svp(ArtSVP ** p_svp, ArtSVP * new_svp)
+{
+  gnome_canvas_item_update_svp(gobj(), p_svp, new_svp);
+}
+
+void Item::update_svp_clip(ArtSVP ** p_svp, ArtSVP * new_svp, ArtSVP * clip_svp)
+{
+  gnome_canvas_item_update_svp_clip(gobj(), p_svp, new_svp, clip_svp);
+}
+
+void Item::request_redraw_svp(const ArtSVP* svp)
+{
+  gnome_canvas_item_request_redraw_svp(gobj(), svp);
+}
+
+void Item::update_bbox(int x1, int y1, int x2, int y2)
+{
+  gnome_canvas_update_bbox(gobj(), x1, y1, x2, y2);
+}
+
+
+Glib::SignalProxy1< bool,GdkEvent* > Item::signal_event()
+{
+  return Glib::SignalProxy1< bool,GdkEvent* >(this, &Item_signal_event_info);
+}
+
+
+Glib::PropertyProxy<Group*> Item::property_parent() 
+{
+  return Glib::PropertyProxy<Group*>(this, "parent");
+}
+
+Glib::PropertyProxy_ReadOnly<Group*> Item::property_parent() const
+{
+  return Glib::PropertyProxy_ReadOnly<Group*>(this, "parent");
+}
+
+
+bool Gnome::Canvas::Item::on_event(GdkEvent* p1)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->event)
+    return (*base->event)(gobj(),p1);
+
+  typedef bool RType;
+  return RType();
+}
+
+
+void Gnome::Canvas::Item::update_vfunc(double* affine, ArtSVP* clip_path, int flags) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->update)
+    (*base->update)(gobj(),affine,clip_path,flags);
+}
+
+void Gnome::Canvas::Item::realize_vfunc() 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->realize)
+    (*base->realize)(gobj());
+}
+
+void Gnome::Canvas::Item::unrealize_vfunc() 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->unrealize)
+    (*base->unrealize)(gobj());
+}
+
+void Gnome::Canvas::Item::map_vfunc() 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->map)
+    (*base->map)(gobj());
+}
+
+void Gnome::Canvas::Item::unmap_vfunc() 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->unmap)
+    (*base->unmap)(gobj());
+}
+
+ArtUta* Gnome::Canvas::Item::coverage_vfunc() 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->coverage)
+    return (*base->coverage)(gobj());
+
+  typedef ArtUta* RType;
+  return RType();
+}
+
+void Gnome::Canvas::Item::draw_vfunc(const Glib::RefPtr<Gdk::Drawable>& drawable, int x, int y, int width, int height) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->draw)
+    (*base->draw)(gobj(),Glib::unwrap(drawable),x,y,width,height);
+}
+
+void Gnome::Canvas::Item::render_vfunc(GnomeCanvasBuf* buf) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->render)
+    (*base->render)(gobj(),buf);
+}
+
+double Gnome::Canvas::Item::point_vfunc(double x, double y, int cx, int cy, GnomeCanvasItem** actual_item) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->point)
+    return (*base->point)(gobj(),x,y,cx,cy,actual_item);
+
+  typedef double RType;
+  return RType();
+}
+
+void Gnome::Canvas::Item::bounds_vfunc(double* x1, double* y1, double* x2, double* y2) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->bounds)
+    (*base->bounds)(gobj(),x1,y1,x2,y2);
+}
+
+
+} // namespace Canvas
+
+} // namespace Gnome
+
+
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/item.h b/libs/libgnomecanvasmm/libgnomecanvasmm/item.h
new file mode 100644
index 0000000000..9265b2018f
--- /dev/null
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/item.h
@@ -0,0 +1,370 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _LIBGNOMECANVASMM_ITEM_H
+#define _LIBGNOMECANVASMM_ITEM_H
+
+#include <glibmm.h>
+
+// -*- C++ -*-
+/* $Id$ */
+
+/* item.h
+ * 
+ * Copyright (C) 1998 EMC Capital Management Inc.
+ * Developed by Havoc Pennington <hp@pobox.com>
+ *
+ * Copyright (C) 1999 The Gtk-- Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/object.h>
+#include <gdkmm/cursor.h>
+#include <libgnomecanvas/gnome-canvas.h>
+
+#include <libgnomecanvasmm/point.h>
+#include <libgnomecanvasmm/affinetrans.h>
+#include <libgnomecanvasmm/properties.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GnomeCanvasItem GnomeCanvasItem;
+typedef struct _GnomeCanvasItemClass GnomeCanvasItemClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gnome
+{
+
+namespace Canvas
+{ class Item_Class; } // namespace Canvas
+
+} // namespace Gnome
+namespace Gnome
+{
+
+namespace Canvas
+{
+
+class Canvas;
+class Group;
+
+
+class Item : public Gtk::Object
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Item CppObjectType;
+  typedef Item_Class CppClassType;
+  typedef GnomeCanvasItem BaseObjectType;
+  typedef GnomeCanvasItemClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~Item();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class Item_Class;
+  static CppClassType item_class_;
+
+  // noncopyable
+  Item(const Item&);
+  Item& operator=(const Item&);
+
+protected:
+  explicit Item(const Glib::ConstructParams& construct_params);
+  explicit Item(GnomeCanvasItem* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GnomeCanvasItem*       gobj()       { return reinterpret_cast<GnomeCanvasItem*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GnomeCanvasItem* gobj() const { return reinterpret_cast<GnomeCanvasItem*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+  virtual bool on_event(GdkEvent* p1);
+
+
+private:
+
+  
+public:
+
+  //:  Move an item by the specified amount
+  
+  /** Moves a canvas item by creating an affine transformation matrix for
+   * translation by using the specified values. This happens in item
+   * local coordinate system, so if you have nontrivial transform, it
+   * most probably does not do, what you want.
+   * @param dx Horizontal offset.
+   * @param dy Vertical offset.
+   */
+  void move(double dx, double dy);
+
+  //: Raise an item in the z-order of its parent group by the specified
+  //: number of positions.  If the number is zero, then the item will
+  //: be made the topmost of its parent group.
+  
+  /** Raises the item in its parent's stack by the specified number of positions.
+   * If the number of positions is greater than the distance to the top of the
+   * stack, then the item is put at the top.
+   * @param positions Number of steps to raise the item.
+   */
+  void raise(int positions);
+
+  //: Lower an item in the z-order of its parent group by the specified
+  //: number of positions.  If the number is zero, then the item will be
+  //: made the bottommost of its parent group.  */
+  
+  /** Lowers the item in its parent's stack by the specified number of positions.
+   * If the number of positions is greater than the distance to the bottom of the
+   * stack, then the item is put at the bottom.
+   * @param positions Number of steps to lower the item.
+   */
+  void lower(int positions);
+
+  //: Raise an item to the top of its parent group's z-order.
+  
+  /** Raises an item to the top of its parent's stack.
+   */
+  void raise_to_top();
+
+  //: Lower an item to the bottom of its parent group's z-order
+  
+  /** Lowers an item to the bottom of its parent's stack.
+   */
+  void lower_to_bottom();
+
+  //: Grab the mouse for the specified item.  Only the events in
+  //: event_mask will be reported.  If cursor is non-NULL, it will be
+  //: used during the duration of the grab.  Time is a proper X event
+  //: time parameter.  Returns the same values as XGrabPointer().
+  int grab(unsigned int event_mask, const Gdk::Cursor& cursor, guint32 etime);
+  int grab(unsigned int event_mask, guint32 etime);
+  
+
+  //: Ungrabs the mouse -- the specified item must be the same that was
+  //: passed to gnome_canvas_item_grab().  Time is a proper X event
+  //: time parameter. 
+  
+  /** Ungrabs the item, which must have been grabbed in the canvas, and ungrabs the
+   * mouse.
+   * @param etime The timestamp for ungrabbing the mouse.
+   */
+  void ungrab(guint32 etime);
+
+  //: These functions convert from a coordinate system to another.  "w"
+  //: is world coordinates and "i" is item coordinates. 
+  
+  /** Converts a coordinate pair from world coordinates to item-relative
+   * coordinates.
+   * @param x X coordinate to convert (input/output value).
+   * @param y Y coordinate to convert (input/output value).
+   */
+  void w2i(double& x, double& y);
+  
+  /** Converts a coordinate pair from item-relative coordinates to world
+   * coordinates.
+   * @param x X coordinate to convert (input/output value).
+   * @param y Y coordinate to convert (input/output value).
+   */
+  void i2w(double& x, double& y);
+
+  //: Used to send all of the keystroke events to a specific item as well 
+  //: as GDK_FOCUS_CHANGE events.
+  
+  /** Makes the specified item take the keyboard focus, so all keyboard events will
+   * be sent to it.  If the canvas widget itself did not have the focus, it grabs
+   * it as well.
+   */
+  void grab_focus();
+
+  //: Fetch the bounding box of the item.  The bounding box may not be 
+  //: exactly tight, but the canvas items will do the best they can.
+  
+  /** Queries the bounding box of a canvas item.  The bounds are returned in the
+   * coordinate system of the item's parent.
+   * @param x1 Leftmost edge of the bounding box (return value).
+   * @param y1 Upper edge of the bounding box (return value).
+   * @param x2 Rightmost edge of the bounding box (return value).
+   * @param y2 Lower edge of the bounding box (return value).
+   */
+  void get_bounds(double& x1, double& y1, double& x2, double& y2) const;
+
+  //: Make the item visible
+  
+  /** Shows a canvas item.  If the item was already shown, then no action is taken.
+   */
+  void show();
+  
+  //: Hide the item
+  
+  /** Hides a canvas item.  If the item was already hidden, then no action is
+   * taken.
+   */
+  void hide();
+
+  //: Apply a relative affine transformation to the item 
+  void affine_relative(const Art::AffineTrans &affine);
+  
+
+  //: Apply an absolute affine transformation to the item
+  void affine_absolute(const Art::AffineTrans &affine);
+  
+
+  //: Gets the affine transform that converts from item-relative
+  //: coordinates to world coordinates
+  Art::AffineTrans get_i2w_affine() const;
+  
+
+  //: Gets the affine transform that converts from item-relative
+  //: coordinates to canvas pixel coordinates
+  Art::AffineTrans get_i2c_affine() const;
+  
+
+  /** Changes the parent of the specified item to be the new group.  The item keeps
+   * its group-relative coordinates as for its old parent, so the item may change
+   * its absolute position within the canvas.
+   * @param new_group A canvas group.
+   */
+  void reparent(Group& new_group);
+
+  /// Returns the canvas we're on.
+  Canvas* get_canvas() const;
+
+    virtual void update_vfunc(double* affine, ArtSVP* clip_path, int flags);
+    virtual void realize_vfunc();
+    virtual void unrealize_vfunc();
+    virtual void map_vfunc();
+    virtual void unmap_vfunc();
+    virtual ArtUta* coverage_vfunc();
+    virtual void draw_vfunc(const Glib::RefPtr<Gdk::Drawable>& drawable, int x, int y, int width, int height);
+    virtual void render_vfunc(GnomeCanvasBuf* buf);
+    virtual double point_vfunc(double x, double y, int cx, int cy, GnomeCanvasItem** actual_item);
+    virtual void bounds_vfunc(double* x1, double* y1, double* x2, double* y2);
+
+  //: Signal: an event ocurred for an item of this type.  The(x, y)
+  //: coordinates are in the canvas world coordinate system.
+  
+
+  Glib::SignalProxy1< bool,GdkEvent* > signal_event();
+
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Group*> property_parent() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Group*> property_parent() const;
+
+
+protected:
+
+  //- For class children use only
+  void item_construct(Group& group);
+
+  //- Unsafe version - can't use a _gtk_string here, C++ doesn't like
+  //- classes being passed before ellipses('...') args
+  void item_construct(Group& group, const gchar* first_arg_name,
+                      va_list ap);
+
+  //- Set arguments - For class children use only
+  void set(const gchar* first_arg_name, ...);
+
+  //: Request that the update method eventually get called.  This should be used
+  //: only by item implementations.
+  
+  /** To be used only by item implementations.  Requests that the canvas queue an
+   * update for the specified item.
+   */
+  void request_update();
+
+
+  /** Resets the bounding box of a canvas item to an empty rectangle.
+   */
+  void reset_bounds();
+  
+  /** Sets the svp to the new value, requesting repaint on what's changed. This
+   * function takes responsibility for freeing new_svp. This routine also adds the
+   * svp's bbox to the item's.
+   * @param p_svp A pointer to the existing svp.
+   * @param new_svp The new svp.
+   */
+  void update_svp(ArtSVP **p_svp, ArtSVP *new_svp);
+  
+  /** Sets the svp to the new value, clipping if necessary, and requesting repaint
+   * on what's changed. This function takes responsibility for freeing new_svp.
+   * @param p_svp A pointer to the existing svp.
+   * @param new_svp The new svp.
+   * @param clip_svp A clip path, if non-null.
+   */
+  void update_svp_clip(ArtSVP **p_svp, ArtSVP *new_svp, ArtSVP *clip_svp);
+  
+  /** Request redraw of the svp if in aa mode, or the entire item in in xlib mode.
+   * @param svp The svp that needs to be redrawn.
+   */
+  void request_redraw_svp(const ArtSVP* svp);
+  
+  /** Sets the bbox to the new value, requesting full repaint.
+   * @param item The canvas item needing update.
+   * @param x1 Left coordinate of the new bounding box.
+   * @param y1 Top coordinate of the new bounding box.
+   * @param x2 Right coordinate of the new bounding box.
+   * @param y2 Bottom coordinate of the new bounding box.
+   */
+  void update_bbox(int x1, int y1, int x2, int y2);
+  
+
+};
+
+} /* namespace Canvas */
+} /* namespace Gnome */
+
+namespace Glib
+{
+  /** @relates Gnome::Canvas::Item
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gnome::Canvas::Item* wrap(GnomeCanvasItem* object, bool take_copy = false);
+}
+#endif /* _LIBGNOMECANVASMM_ITEM_H */
+
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/line.cc b/libs/libgnomecanvasmm/libgnomecanvasmm/line.cc
new file mode 100644
index 0000000000..5b12c69ba6
--- /dev/null
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/line.cc
@@ -0,0 +1,388 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <libgnomecanvasmm/line.h>
+#include <libgnomecanvasmm/private/line_p.h>
+
+/* $Id$ */
+
+/* line.ccg
+ *
+ * Copyright (C) 1998 EMC Capital Management Inc.
+ * Developed by Havoc Pennington <hp@pobox.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+//#include <libgnomecanvasmm/group.h>
+
+namespace Gnome
+{
+
+namespace Canvas
+{
+
+Points::Points(size_type nbpoints)
+: std::vector<Art::Point>(nbpoints), points_(0), owned_(false)
+{}
+
+Points::Points(GnomeCanvasPoints *castitem)
+: points_(castitem),owned_(false)
+{
+  reserve(points_->num_points);
+
+  //GnomeCanvasPoints has an array of doubles, used 2 at a time:
+  int i = 0;
+  for(iterator it = begin(); i < points_->num_points; i += 2, ++it)
+  {
+    (*it).set_x(points_->coords[i]);
+    (*it).set_y(points_->coords[i+1]);
+  }
+}
+
+Points::~Points()
+{
+  if (owned_ && points_)
+    gnome_canvas_points_free(points_);
+}
+
+Points::operator bool() const
+{
+  return (!is_null());
+}
+
+bool Points::is_null() const
+{
+  return size() == 0;
+}
+
+GnomeCanvasPoints* Points::_gobj() const
+{
+  int i = 0;
+  
+  if(!points_)
+  {
+    points_ = gnome_canvas_points_new(size());
+    owned_ = true;
+  }
+  else if(size() != static_cast<unsigned int>(points_->num_points))
+  {
+    if (owned_)
+     gnome_canvas_points_free(points_);
+
+    points_ = gnome_canvas_points_new(size());
+    owned_ = true;
+  }
+  
+  for(const_iterator it = begin(); it != end(); ++it, i+=2)
+  {
+    points_->coords[i] = (*it).get_x();
+    points_->coords[i+1] = (*it).get_y();
+  }
+
+  return points_;
+}
+
+
+Line::Line(Group& parentx)
+  : Item(GNOME_CANVAS_ITEM(g_object_new(get_type(),0)))
+{
+  item_construct(parentx);
+}
+
+Line::Line(Group& parentx, const Points& points)
+  : Item(GNOME_CANVAS_ITEM(g_object_new(get_type(),0)))
+{
+  item_construct(parentx);
+  property_points().set_value(points);
+}
+
+} /* namespace Canvas */
+} /* namespace Gnome */
+
+
+// static
+GType Glib::Value<Gnome::Canvas::Points>::value_type()
+{
+  return Gnome::Canvas::Points::get_type();
+}
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gnome::Canvas::Line* wrap(GnomeCanvasLine* object, bool take_copy)
+{
+  return dynamic_cast<Gnome::Canvas::Line *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gnome
+{
+
+namespace Canvas
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& Line_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &Line_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gnome_canvas_line_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void Line_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* Line_Class::wrap_new(GObject* o)
+{
+  return manage(new Line((GnomeCanvasLine*)(o)));
+
+}
+
+
+/* The implementation: */
+
+Line::Line(const Glib::ConstructParams& construct_params)
+:
+  Item(construct_params)
+{
+  }
+
+Line::Line(GnomeCanvasLine* castitem)
+:
+  Item((GnomeCanvasItem*)(castitem))
+{
+  }
+
+Line::~Line()
+{
+  destroy_();
+}
+
+Line::CppClassType Line::line_class_; // initialize static member
+
+GType Line::get_type()
+{
+  return line_class_.init().get_type();
+}
+
+GType Line::get_base_type()
+{
+  return gnome_canvas_line_get_type();
+}
+
+
+Glib::PropertyProxy<Points> Line::property_points() 
+{
+  return Glib::PropertyProxy<Points>(this, "points");
+}
+
+Glib::PropertyProxy_ReadOnly<Points> Line::property_points() const
+{
+  return Glib::PropertyProxy_ReadOnly<Points>(this, "points");
+}
+
+Glib::PropertyProxy<Glib::ustring> Line::property_fill_color() 
+{
+  return Glib::PropertyProxy<Glib::ustring>(this, "fill-color");
+}
+
+Glib::PropertyProxy_ReadOnly<Glib::ustring> Line::property_fill_color() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "fill-color");
+}
+
+Glib::PropertyProxy<Gdk::Color> Line::property_fill_color_gdk() 
+{
+  return Glib::PropertyProxy<Gdk::Color>(this, "fill-color-gdk");
+}
+
+Glib::PropertyProxy_ReadOnly<Gdk::Color> Line::property_fill_color_gdk() const
+{
+  return Glib::PropertyProxy_ReadOnly<Gdk::Color>(this, "fill-color-gdk");
+}
+
+Glib::PropertyProxy<guint> Line::property_fill_color_rgba() 
+{
+  return Glib::PropertyProxy<guint>(this, "fill-color-rgba");
+}
+
+Glib::PropertyProxy_ReadOnly<guint> Line::property_fill_color_rgba() const
+{
+  return Glib::PropertyProxy_ReadOnly<guint>(this, "fill-color-rgba");
+}
+
+Glib::PropertyProxy< Glib::RefPtr<Gdk::Bitmap> > Line::property_fill_stipple() 
+{
+  return Glib::PropertyProxy< Glib::RefPtr<Gdk::Bitmap> >(this, "fill-stipple");
+}
+
+Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Bitmap> > Line::property_fill_stipple() const
+{
+  return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Bitmap> >(this, "fill-stipple");
+}
+
+Glib::PropertyProxy<guint> Line::property_width_pixels() 
+{
+  return Glib::PropertyProxy<guint>(this, "width-pixels");
+}
+
+Glib::PropertyProxy_ReadOnly<guint> Line::property_width_pixels() const
+{
+  return Glib::PropertyProxy_ReadOnly<guint>(this, "width-pixels");
+}
+
+Glib::PropertyProxy<double> Line::property_width_units() 
+{
+  return Glib::PropertyProxy<double>(this, "width-units");
+}
+
+Glib::PropertyProxy_ReadOnly<double> Line::property_width_units() const
+{
+  return Glib::PropertyProxy_ReadOnly<double>(this, "width-units");
+}
+
+Glib::PropertyProxy<Gdk::CapStyle> Line::property_cap_style() 
+{
+  return Glib::PropertyProxy<Gdk::CapStyle>(this, "cap-style");
+}
+
+Glib::PropertyProxy_ReadOnly<Gdk::CapStyle> Line::property_cap_style() const
+{
+  return Glib::PropertyProxy_ReadOnly<Gdk::CapStyle>(this, "cap-style");
+}
+
+Glib::PropertyProxy<Gdk::JoinStyle> Line::property_join_style() 
+{
+  return Glib::PropertyProxy<Gdk::JoinStyle>(this, "join-style");
+}
+
+Glib::PropertyProxy_ReadOnly<Gdk::JoinStyle> Line::property_join_style() const
+{
+  return Glib::PropertyProxy_ReadOnly<Gdk::JoinStyle>(this, "join-style");
+}
+
+Glib::PropertyProxy<Gdk::LineStyle> Line::property_line_style() 
+{
+  return Glib::PropertyProxy<Gdk::LineStyle>(this, "line-style");
+}
+
+Glib::PropertyProxy_ReadOnly<Gdk::LineStyle> Line::property_line_style() const
+{
+  return Glib::PropertyProxy_ReadOnly<Gdk::LineStyle>(this, "line-style");
+}
+
+Glib::PropertyProxy<bool> Line::property_first_arrowhead() 
+{
+  return Glib::PropertyProxy<bool>(this, "first-arrowhead");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Line::property_first_arrowhead() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "first-arrowhead");
+}
+
+Glib::PropertyProxy<bool> Line::property_last_arrowhead() 
+{
+  return Glib::PropertyProxy<bool>(this, "last-arrowhead");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Line::property_last_arrowhead() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "last-arrowhead");
+}
+
+Glib::PropertyProxy<bool> Line::property_smooth() 
+{
+  return Glib::PropertyProxy<bool>(this, "smooth");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Line::property_smooth() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "smooth");
+}
+
+Glib::PropertyProxy<guint> Line::property_spline_steps() 
+{
+  return Glib::PropertyProxy<guint>(this, "spline-steps");
+}
+
+Glib::PropertyProxy_ReadOnly<guint> Line::property_spline_steps() const
+{
+  return Glib::PropertyProxy_ReadOnly<guint>(this, "spline-steps");
+}
+
+Glib::PropertyProxy<double> Line::property_arrow_shape_a() 
+{
+  return Glib::PropertyProxy<double>(this, "arrow-shape-a");
+}
+
+Glib::PropertyProxy_ReadOnly<double> Line::property_arrow_shape_a() const
+{
+  return Glib::PropertyProxy_ReadOnly<double>(this, "arrow-shape-a");
+}
+
+Glib::PropertyProxy<double> Line::property_arrow_shape_b() 
+{
+  return Glib::PropertyProxy<double>(this, "arrow-shape-b");
+}
+
+Glib::PropertyProxy_ReadOnly<double> Line::property_arrow_shape_b() const
+{
+  return Glib::PropertyProxy_ReadOnly<double>(this, "arrow-shape-b");
+}
+
+Glib::PropertyProxy<double> Line::property_arrow_shape_c() 
+{
+  return Glib::PropertyProxy<double>(this, "arrow-shape-c");
+}
+
+Glib::PropertyProxy_ReadOnly<double> Line::property_arrow_shape_c() const
+{
+  return Glib::PropertyProxy_ReadOnly<double>(this, "arrow-shape-c");
+}
+
+
+} // namespace Canvas
+
+} // namespace Gnome
+
+
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/line.h b/libs/libgnomecanvasmm/libgnomecanvasmm/line.h
new file mode 100644
index 0000000000..ab792c8abd
--- /dev/null
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/line.h
@@ -0,0 +1,461 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _LIBGNOMECANVASMM_LINE_H
+#define _LIBGNOMECANVASMM_LINE_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* line.h
+ * 
+ * Copyright (C) 1998 EMC Capital Management Inc.
+ * Developed by Havoc Pennington <hp@pobox.com>
+ *
+ * Copyright (C) 1999 The Gtk-- Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <libgnomecanvasmm/item.h>
+#include <libgnomecanvas/gnome-canvas-line.h>
+#include <libgnomecanvas/gnome-canvas-util.h>
+#include <libgnomecanvas/libgnomecanvas.h>
+#include <vector>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GnomeCanvasLine GnomeCanvasLine;
+typedef struct _GnomeCanvasLineClass GnomeCanvasLineClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gnome
+{
+
+namespace Canvas
+{ class Line_Class; } // namespace Canvas
+
+} // namespace Gnome
+namespace Gnome
+{
+
+namespace Canvas
+{
+
+class GnomeGroup;
+
+// Sample use of Gnome_CanvasPoints :
+
+//   Gnome_CanvasPoints points;
+//  
+//   points.push_back(Art::Point(0, 0));
+//   points.push_back(Art::Point(100,0));
+//   points.push_back(Art::Point(0,100));
+//   points.push_back(Art::Point(100,100));
+//
+//   line = new Gnome_CanvasLine(&m_canvasgroup,points);
+
+//using std::vector;
+
+/** Wrapper for GnomeCanvasPoints.
+ * GnomeCanvasPoints is actually a BoxedType,
+ * but this acts in a similar way, with the advantage of acting like a std::vector.
+ */
+class Points : public std::vector<Art::Point>
+{
+public:
+  Points(size_type nbpoints = 0);
+  explicit Points(GnomeCanvasPoints* castitem);
+  ~Points();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef  GnomeCanvasPoints BaseObjectType;  //So that this works with tempaltes that are intended for normal BoxedTypes.
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  operator bool() const;
+  bool is_null() const;
+
+  const GnomeCanvasPoints* gobj() const { return _gobj(); }
+  GnomeCanvasPoints* gobj() { return _gobj(); }
+  static GType get_type () { return GNOME_TYPE_CANVAS_POINTS; }
+
+protected:
+  GnomeCanvasPoints* _gobj() const;
+  mutable GnomeCanvasPoints* points_;
+  mutable bool owned_;
+};
+
+
+class Line : public Item
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Line CppObjectType;
+  typedef Line_Class CppClassType;
+  typedef GnomeCanvasLine BaseObjectType;
+  typedef GnomeCanvasLineClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~Line();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class Line_Class;
+  static CppClassType line_class_;
+
+  // noncopyable
+  Line(const Line&);
+  Line& operator=(const Line&);
+
+protected:
+  explicit Line(const Glib::ConstructParams& construct_params);
+  explicit Line(GnomeCanvasLine* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GnomeCanvasLine*       gobj()       { return reinterpret_cast<GnomeCanvasLine*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GnomeCanvasLine* gobj() const { return reinterpret_cast<GnomeCanvasLine*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+private:
+
+public:
+  explicit Line(Group& parent);
+  Line(Group& parent, const Points& points);
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Points> property_points() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Points> property_points() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Glib::ustring> property_fill_color() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::ustring> property_fill_color() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Gdk::Color> property_fill_color_gdk() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Gdk::Color> property_fill_color_gdk() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<guint> property_fill_color_rgba() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<guint> property_fill_color_rgba() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy< Glib::RefPtr<Gdk::Bitmap> > property_fill_stipple() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Bitmap> > property_fill_stipple() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<guint> property_width_pixels() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<guint> property_width_pixels() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<double> property_width_units() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<double> property_width_units() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Gdk::CapStyle> property_cap_style() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Gdk::CapStyle> property_cap_style() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Gdk::JoinStyle> property_join_style() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Gdk::JoinStyle> property_join_style() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Gdk::LineStyle> property_line_style() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Gdk::LineStyle> property_line_style() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_first_arrowhead() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_first_arrowhead() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_last_arrowhead() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_last_arrowhead() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_smooth() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_smooth() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<guint> property_spline_steps() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<guint> property_spline_steps() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<double> property_arrow_shape_a() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<double> property_arrow_shape_a() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<double> property_arrow_shape_b() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<double> property_arrow_shape_b() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<double> property_arrow_shape_c() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<double> property_arrow_shape_c() const;
+
+
+};
+
+} /* namespace Canvas */
+} /* namespace Gnome */
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gnome::Canvas::Points> : public Value_Boxed<Gnome::Canvas::Points>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+namespace Glib
+{
+  /** @relates Gnome::Canvas::Line
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gnome::Canvas::Line* wrap(GnomeCanvasLine* object, bool take_copy = false);
+}
+#endif /* _LIBGNOMECANVASMM_LINE_H */
+
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/path-def.cc b/libs/libgnomecanvasmm/libgnomecanvasmm/path-def.cc
new file mode 100644
index 0000000000..528c3f8153
--- /dev/null
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/path-def.cc
@@ -0,0 +1,249 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <libgnomecanvasmm/path-def.h>
+#include <libgnomecanvasmm/private/path-def_p.h>
+
+/* path-def.cc
+ *
+ * Copyright (C) 2002 The libgnomecanvasmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+namespace Gnome
+{
+
+namespace Canvas
+{
+Gnome::Art::Point PathDef::currentpoint() const
+{
+  Gnome::Art::Point point;
+  gnome_canvas_path_def_currentpoint(gobj(), point.gobj());
+  return point;
+}
+
+
+} /* namespace Canvas */
+
+} /* namespace Gnome */
+
+namespace
+{
+} // anonymous namespace
+
+
+/* Why reinterpret_cast<PathDef*>(gobject) is needed:
+ *
+ * A PathDef instance is in fact always a GnomeCanvasPathDef instance.
+ * Unfortunately, GnomeCanvasPathDef cannot be a member of PathDef,
+ * because it is an opaque struct.  Also, the C interface does not provide
+ * any hooks to install a destroy notification handler, thus we cannot
+ * wrap it dynamically either.
+ *
+ * The cast works because PathDef does not have any member data, and
+ * it is impossible to derive from it.  This is ensured by not implementing
+ * the (protected) default constructor.  The ctor is protected rather than
+ * private just to avoid a compile warning.
+ */
+
+namespace Glib
+{
+
+Glib::RefPtr<Gnome::Canvas::PathDef> wrap(GnomeCanvasPathDef* object, bool take_copy)
+{
+  if(take_copy && object)
+    gnome_canvas_path_def_duplicate(object);
+
+  // See the comment at the top of this file, if you want to know why the cast works.
+  return Glib::RefPtr<Gnome::Canvas::PathDef>(reinterpret_cast<Gnome::Canvas::PathDef*>(object));
+}
+
+} // namespace Glib
+
+
+namespace Gnome
+{
+
+namespace Canvas
+{
+
+
+// static
+Glib::RefPtr<PathDef> PathDef::create()
+{
+  // See the comment at the top of this file, if you want to know why the cast works.
+  return Glib::RefPtr<PathDef>(reinterpret_cast<PathDef*>(gnome_canvas_path_def_new()));
+}
+
+void PathDef::reference() const
+{
+  // See the comment at the top of this file, if you want to know why the cast works.
+  gnome_canvas_path_def_duplicate(reinterpret_cast<GnomeCanvasPathDef*>(const_cast<PathDef*>(this)));
+}
+
+void PathDef::unreference() const
+{
+  // See the comment at the top of this file, if you want to know why the cast works.
+  gnome_canvas_path_def_unref(reinterpret_cast<GnomeCanvasPathDef*>(const_cast<PathDef*>(this)));
+}
+
+GnomeCanvasPathDef* PathDef::gobj()
+{
+  // See the comment at the top of this file, if you want to know why the cast works.
+  return reinterpret_cast<GnomeCanvasPathDef*>(this);
+}
+
+const GnomeCanvasPathDef* PathDef::gobj() const
+{
+  // See the comment at the top of this file, if you want to know why the cast works.
+  return reinterpret_cast<const GnomeCanvasPathDef*>(this);
+}
+
+GnomeCanvasPathDef* PathDef::gobj_copy() const
+{
+  // See the comment at the top of this file, if you want to know why the cast works.
+  GnomeCanvasPathDef *const gobject = reinterpret_cast<GnomeCanvasPathDef*>(const_cast<PathDef*>(this));
+  gnome_canvas_path_def_duplicate(gobject);
+  return gobject;
+}
+
+
+Glib::RefPtr<PathDef> PathDef::create(int length)
+{
+  return Glib::wrap(gnome_canvas_path_def_new_sized(length));
+}
+
+Glib::RefPtr<PathDef> PathDef::create(ArtBpath& bpath)
+{
+  return Glib::wrap(gnome_canvas_path_def_new_from_bpath(&(bpath)));
+}
+
+Glib::RefPtr<PathDef> PathDef::open_parts()
+{
+  return Glib::wrap(gnome_canvas_path_def_open_parts(gobj()));
+}
+
+Glib::RefPtr<PathDef> PathDef::closed_parts()
+{
+  return Glib::wrap(gnome_canvas_path_def_closed_parts(gobj()));
+}
+
+Glib::RefPtr<PathDef> PathDef::close_all()
+{
+  return Glib::wrap(gnome_canvas_path_def_close_all(gobj()));
+}
+
+void PathDef::finish()
+{
+  gnome_canvas_path_def_finish(gobj());
+}
+
+void PathDef::ensure_space(int space)
+{
+  gnome_canvas_path_def_ensure_space(gobj(), space);
+}
+
+void PathDef::reset()
+{
+  gnome_canvas_path_def_reset(gobj());
+}
+
+void PathDef::moveto(double x, double y)
+{
+  gnome_canvas_path_def_moveto(gobj(), x, y);
+}
+
+void PathDef::lineto(double x, double y)
+{
+  gnome_canvas_path_def_lineto(gobj(), x, y);
+}
+
+void PathDef::lineto_moving(double x, double y)
+{
+  gnome_canvas_path_def_lineto_moving(gobj(), x, y);
+}
+
+void PathDef::curveto(double x1, double y1, double x2, double y2, double x3, double y3)
+{
+  gnome_canvas_path_def_curveto(gobj(), x1, y1, x2, y2, x3, y3);
+}
+
+void PathDef::closepath()
+{
+  gnome_canvas_path_def_closepath(gobj());
+}
+
+void PathDef::closepath_current()
+{
+  gnome_canvas_path_def_closepath_current(gobj());
+}
+
+ArtBpath* PathDef::get_bpath() const
+{
+  return gnome_canvas_path_def_bpath(const_cast<GnomeCanvasPathDef*>(gobj()));
+}
+
+ArtBpath* PathDef::first_bpath() const
+{
+  return gnome_canvas_path_def_first_bpath(const_cast<GnomeCanvasPathDef*>(gobj()));
+}
+
+ArtBpath* PathDef::last_bpath() const
+{
+  return gnome_canvas_path_def_last_bpath(const_cast<GnomeCanvasPathDef*>(gobj()));
+}
+
+bool PathDef::is_empty() const
+{
+  return gnome_canvas_path_def_is_empty(const_cast<GnomeCanvasPathDef*>(gobj()));
+}
+
+int PathDef::length() const
+{
+  return gnome_canvas_path_def_length(const_cast<GnomeCanvasPathDef*>(gobj()));
+}
+
+bool PathDef::has_currentpoint() const
+{
+  return gnome_canvas_path_def_has_currentpoint(const_cast<GnomeCanvasPathDef*>(gobj()));
+}
+
+bool PathDef::any_open() const
+{
+  return gnome_canvas_path_def_any_open(const_cast<GnomeCanvasPathDef*>(gobj()));
+}
+
+bool PathDef::all_open() const
+{
+  return gnome_canvas_path_def_all_open(const_cast<GnomeCanvasPathDef*>(gobj()));
+}
+
+bool PathDef::any_closed() const
+{
+  return gnome_canvas_path_def_any_closed(const_cast<GnomeCanvasPathDef*>(gobj()));
+}
+
+bool PathDef::all_closed() const
+{
+  return gnome_canvas_path_def_all_closed(const_cast<GnomeCanvasPathDef*>(gobj()));
+}
+
+
+} // namespace Canvas
+
+} // namespace Gnome
+
+
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/path-def.h b/libs/libgnomecanvasmm/libgnomecanvasmm/path-def.h
new file mode 100644
index 0000000000..4f528f5806
--- /dev/null
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/path-def.h
@@ -0,0 +1,284 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _LIBGNOMECANVASMM_PATH_DEF_H
+#define _LIBGNOMECANVASMM_PATH_DEF_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* path-def.h
+ * 
+ *
+ * Copyright (C) 2002 The libgnomecanvasmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <libgnomecanvasmm/point.h>
+#include <glibmm/containers.h>
+#include <libgnomecanvas/gnome-canvas-path-def.h>
+#include <libart_lgpl/art_bpath.h>
+#include <libart_lgpl/art_point.h>
+#include <libart_lgpl/art_bpath.h>
+
+
+namespace Gnome
+{
+
+namespace Canvas
+{
+
+class PathDef
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef PathDef CppObjectType;
+  typedef GnomeCanvasPathDef BaseObjectType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  static Glib::RefPtr<PathDef> create();
+
+  // For use with Glib::RefPtr<> only.
+  void reference()   const;
+  void unreference() const;
+
+  ///Provides access to the underlying C instance.
+  GnomeCanvasPathDef*       gobj();
+
+  ///Provides access to the underlying C instance.
+  const GnomeCanvasPathDef* gobj() const;
+
+  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
+  GnomeCanvasPathDef* gobj_copy() const;
+
+protected:
+  // Do not derive this.  Gnome::Canvas::PathDef can neither be constructed nor deleted.
+  PathDef();
+  void operator delete(void*, size_t);
+
+private:
+  // noncopyable
+  PathDef(const PathDef&);
+  PathDef& operator=(const PathDef&);
+
+
+public:
+  //gtkmmproc error: gnome_canvas_path_def_new : method defs lookup failed (1)
+  
+  /** This funtion creates a new #gnome_canvas_path_def with @a length 
+   * number of points allocated. It is useful, if you know the exact
+   * number of points in path, so you can avoid automatic point
+   * array reallocation.
+   * @param length Number of points to allocate for the path.
+   * @return The new canvas path definition.
+   */
+  static Glib::RefPtr<PathDef> create(int length);
+  
+  /** This function constructs a new #gnome_canvas_path_def and uses the
+   * passed @a bpath  as the contents.  The passed bpath should not be
+   * static as the path definition is editable when constructed with
+   * this function. Also, passed bpath will be freed with art_free, if
+   * path is destroyed, so use it with caution.
+   * For constructing a #gnome_canvas_path_def
+   * from (non-modifiable) bpath use
+   * #gnome_canvas_path_def_new_from_static_bpath.
+   * @param bpath Libart bezier path.
+   * @return The new canvas path definition that is populated with the
+   * passed bezier path, if the @a bpath  is bad <tt>0</tt> is returned.
+   */
+  static Glib::RefPtr<PathDef> create(ArtBpath& bpath);
+
+  //GnomeCanvasPathDef * gnome_canvas_path_def_new_from_static_bpath (ArtBpath * bpath);
+  //GnomeCanvasPathDef * gnome_canvas_path_def_new_from_foreign_bpath (ArtBpath * bpath);
+
+  //GnomeCanvasPathDef * gnome_canvas_path_def_concat (const GSList * list);
+  //GSList * gnome_canvas_path_def_split (const GnomeCanvasPathDef * path);
+  
+  /** This function creates a new GnomeCanvasPathDef that contains all of
+   * the open segments on the passed @a path .
+   * @return A new GnomeCanvasPathDef that contains all of the open segemtns in @a path .
+   */
+  Glib::RefPtr<PathDef> open_parts();
+  
+  /** This function returns a new GnomeCanvasPathDef that contains the
+   * all of close parts of passed @a path .
+   * @return A new GnomeCanvasPathDef that contains all of the closed
+   * parts of passed @a path .
+   */
+  Glib::RefPtr<PathDef> closed_parts();
+  
+  /** This function closes all of the open segments in the passed path
+   * and returns a new GnomeCanvasPathDef.
+   * @return A GnomeCanvasPathDef that contains the contents of @a path 
+   * but has modified the path is fully closed.
+   */
+  Glib::RefPtr<PathDef> close_all();
+
+  
+  /** Trims dynamic point array to exact length of path.
+   */
+  void finish();
+  
+  /** This function ensures that enough space for @a space  points is
+   * allocated at the end of the path.
+   * @param space Number of points to guarantee are allocated at the end of
+   * the path.
+   */
+  void ensure_space(int space);
+
+  
+  /** This function clears the contents of the passed @a path .
+   */
+  void reset();
+
+  
+  /** This function adds starts new subpath on @a path , and sets its
+   * starting point to @a x  and @a y . If current subpath is empty, it
+   * simply changes its starting coordinates to new values.
+   * @param x X coordinate.
+   * @param y Y coordinate.
+   */
+  void moveto(double x, double y);
+  
+  /** This function add a line segment to the passed @a path  with the
+   * specified @a x  and @a y  coordinates.
+   * @param x X coordinate.
+   * @param y Y coordinate.
+   */
+  void lineto(double x, double y);
+
+  
+  /** This functions adds a new line segment with loose endpoint to the path, or
+   * if endpoint is already loose, changes its coordinates to @a x , @a y . You
+   * can change the coordinates of loose endpoint as many times as you want,
+   * the last ones set will be fixed, if you continue line. This is useful
+   * for handling drawing with mouse.
+   * @param x X coordinate.
+   * @param y Y coordinate.
+   */
+  void lineto_moving(double x, double y);
+  
+  /** This function adds a bezier curve segment to the path definition.
+   * @param x0 First control point x coordinate.
+   * @param y0 First control point y coordinate.
+   * @param x1 Second control point x coordinate.
+   * @param y1 Second control point y coordinate.
+   * @param x2 End of curve x coordinate.
+   * @param y2 End of curve y coordinate.
+   */
+  void curveto(double x1, double y1, double x2, double y2, double x3, double y3);
+  
+  /** This function closes the last subpath of @a path , adding a ART_LINETO to
+   * subpath starting point, if needed and changing starting pathcode to
+   * ART_MOVETO
+   */
+  void closepath();
+
+  
+  /** This function closes the last subpath by setting the coordinates of
+   * the endpoint of the last segment (line or curve) to starting point.
+   */
+  void closepath_current();
+
+  Gnome::Art::Point currentpoint() const;
+
+  
+  /** This function returns a ArtBpath that consists of the path
+   * definition.
+   * @return ArtBpath.
+   */
+  ArtBpath* get_bpath() const;
+  
+  /** This function returns the first ArtBpath point in the definition.
+   * @return ArtBpath being the first point in the path definition or
+   * null if no points are defined.
+   */
+  ArtBpath* first_bpath() const;
+  
+  /** This function returns pointer to the last ArtBpath segment in the path
+   * definition.
+   * @return ArtBpath, being the last segment in the path definition or
+   * null if no line segments have been defined.
+   */
+  ArtBpath* last_bpath() const;
+
+  
+  /** This function is a boolean test to see if the path is empty,
+   * meaning containing no line segments.
+   * @return Boolean, indicating if the path is empty.
+   */
+  bool is_empty() const;
+  
+  /** This function returns the length of the path definition.  Not
+   * Euclidian length of the path but rather the number of points on the
+   * path.
+   * @return Integer, number of points on the path.
+   */
+  int length() const;
+  
+  /** This function is a boolean test checking to see if the path has a
+   * current point defined. Current point will be set by line operators,
+   * and cleared by closing subpath.
+   * @return Boolean, indicating if the path has a current point defined.
+   */
+  bool has_currentpoint() const;
+  
+  /** This function returns a boolean value indicating if the path has
+   * any open segments.
+   * @return Boolean, indicating if the path has any open segments.
+   */
+  bool any_open() const;
+  
+  /** This function returns a boolean value indicating if the path only
+   * contains open segments.
+   * @return Boolean, indicating if the path has all open segments.
+   */
+  bool all_open() const;
+  
+  /** This function returns a boolean valid indicating if the path has
+   * any closed segements.
+   * @return Boolean, indicating if the path has any closed segments.
+   */
+  bool any_closed() const;
+  
+  /** This function returns a boolean value indicating if the path only
+   * contains closed segments.
+   * @return Boolean, indicating if the path has all closed segments.
+   */
+  bool all_closed() const;
+
+
+};
+
+} /* namespace Canvas */
+
+} /* namespace Gnome */
+
+
+namespace Glib
+{
+
+  /** @relates Gnome::Canvas::PathDef
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Gnome::Canvas::PathDef> wrap(GnomeCanvasPathDef* object, bool take_copy = false);
+
+} // namespace Glib
+
+#endif /* _LIBGNOMECANVASMM_PATH_DEF_H */
+
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/pixbuf.cc b/libs/libgnomecanvasmm/libgnomecanvasmm/pixbuf.cc
new file mode 100644
index 0000000000..c0b49a70dc
--- /dev/null
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/pixbuf.cc
@@ -0,0 +1,277 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <libgnomecanvasmm/pixbuf.h>
+#include <libgnomecanvasmm/private/pixbuf_p.h>
+
+/* $Id$ */
+
+/* pixbuf.cc
+ *
+ * Copyright (C) 2002 The libgnomecanvasmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+namespace Gnome
+{
+
+namespace Canvas
+{
+
+Pixbuf::Pixbuf (Group& parent, 
+                double x, double y, 
+                const Glib::RefPtr<Gdk::Pixbuf>& image)
+  : Item (GNOME_CANVAS_ITEM (g_object_new (get_type (), NULL)))
+{
+  item_construct (parent);
+  set ("x", x, 
+       "y", y, 
+       "pixbuf", image->gobj (),
+       "width", (double) gdk_pixbuf_get_width (image->gobj ()),
+       "height", (double) gdk_pixbuf_get_height (image->gobj ()),
+       NULL);
+}
+
+
+Pixbuf::Pixbuf (Group& parent)
+  : Item (GNOME_CANVAS_ITEM (g_object_new (get_type (), NULL)))
+{
+  item_construct (parent);
+}
+
+
+}
+
+}
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gnome::Canvas::Pixbuf* wrap(GnomeCanvasPixbuf* object, bool take_copy)
+{
+  return dynamic_cast<Gnome::Canvas::Pixbuf *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gnome
+{
+
+namespace Canvas
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& Pixbuf_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &Pixbuf_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gnome_canvas_pixbuf_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void Pixbuf_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* Pixbuf_Class::wrap_new(GObject* o)
+{
+  return manage(new Pixbuf((GnomeCanvasPixbuf*)(o)));
+
+}
+
+
+/* The implementation: */
+
+Pixbuf::Pixbuf(const Glib::ConstructParams& construct_params)
+:
+  Item(construct_params)
+{
+  }
+
+Pixbuf::Pixbuf(GnomeCanvasPixbuf* castitem)
+:
+  Item((GnomeCanvasItem*)(castitem))
+{
+  }
+
+Pixbuf::~Pixbuf()
+{
+  destroy_();
+}
+
+Pixbuf::CppClassType Pixbuf::pixbuf_class_; // initialize static member
+
+GType Pixbuf::get_type()
+{
+  return pixbuf_class_.init().get_type();
+}
+
+GType Pixbuf::get_base_type()
+{
+  return gnome_canvas_pixbuf_get_type();
+}
+
+
+Glib::PropertyProxy< Glib::RefPtr<Gdk::Pixbuf> > Pixbuf::property_pixbuf() 
+{
+  return Glib::PropertyProxy< Glib::RefPtr<Gdk::Pixbuf> >(this, "pixbuf");
+}
+
+Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Pixbuf> > Pixbuf::property_pixbuf() const
+{
+  return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Pixbuf> >(this, "pixbuf");
+}
+
+Glib::PropertyProxy<double> Pixbuf::property_width() 
+{
+  return Glib::PropertyProxy<double>(this, "width");
+}
+
+Glib::PropertyProxy_ReadOnly<double> Pixbuf::property_width() const
+{
+  return Glib::PropertyProxy_ReadOnly<double>(this, "width");
+}
+
+Glib::PropertyProxy<bool> Pixbuf::property_width_set() 
+{
+  return Glib::PropertyProxy<bool>(this, "width-set");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Pixbuf::property_width_set() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "width-set");
+}
+
+Glib::PropertyProxy<bool> Pixbuf::property_width_in_pixels() 
+{
+  return Glib::PropertyProxy<bool>(this, "width-in-pixels");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Pixbuf::property_width_in_pixels() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "width-in-pixels");
+}
+
+Glib::PropertyProxy<double> Pixbuf::property_height() 
+{
+  return Glib::PropertyProxy<double>(this, "height");
+}
+
+Glib::PropertyProxy_ReadOnly<double> Pixbuf::property_height() const
+{
+  return Glib::PropertyProxy_ReadOnly<double>(this, "height");
+}
+
+Glib::PropertyProxy<bool> Pixbuf::property_height_set() 
+{
+  return Glib::PropertyProxy<bool>(this, "height-set");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Pixbuf::property_height_set() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "height-set");
+}
+
+Glib::PropertyProxy<bool> Pixbuf::property_height_in_pixels() 
+{
+  return Glib::PropertyProxy<bool>(this, "height-in-pixels");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Pixbuf::property_height_in_pixels() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "height-in-pixels");
+}
+
+Glib::PropertyProxy<double> Pixbuf::property_x() 
+{
+  return Glib::PropertyProxy<double>(this, "x");
+}
+
+Glib::PropertyProxy_ReadOnly<double> Pixbuf::property_x() const
+{
+  return Glib::PropertyProxy_ReadOnly<double>(this, "x");
+}
+
+Glib::PropertyProxy<bool> Pixbuf::property_x_in_pixels() 
+{
+  return Glib::PropertyProxy<bool>(this, "x-in-pixels");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Pixbuf::property_x_in_pixels() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "x-in-pixels");
+}
+
+Glib::PropertyProxy<double> Pixbuf::property_y() 
+{
+  return Glib::PropertyProxy<double>(this, "y");
+}
+
+Glib::PropertyProxy_ReadOnly<double> Pixbuf::property_y() const
+{
+  return Glib::PropertyProxy_ReadOnly<double>(this, "y");
+}
+
+Glib::PropertyProxy<bool> Pixbuf::property_y_in_pixels() 
+{
+  return Glib::PropertyProxy<bool>(this, "y-in-pixels");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Pixbuf::property_y_in_pixels() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "y-in-pixels");
+}
+
+Glib::PropertyProxy<Gtk::AnchorType> Pixbuf::property_anchor() 
+{
+  return Glib::PropertyProxy<Gtk::AnchorType>(this, "anchor");
+}
+
+Glib::PropertyProxy_ReadOnly<Gtk::AnchorType> Pixbuf::property_anchor() const
+{
+  return Glib::PropertyProxy_ReadOnly<Gtk::AnchorType>(this, "anchor");
+}
+
+
+} // namespace Canvas
+
+} // namespace Gnome
+
+
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/pixbuf.h b/libs/libgnomecanvasmm/libgnomecanvasmm/pixbuf.h
new file mode 100644
index 0000000000..6b7922318e
--- /dev/null
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/pixbuf.h
@@ -0,0 +1,321 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _LIBGNOMECANVASMM_PIXBUF_H
+#define _LIBGNOMECANVASMM_PIXBUF_H
+
+#include <glibmm.h>
+
+// -*- C++ -*-
+/* $Id$ */
+
+/* pixbuf.h
+ *
+ *
+ * Copyright (C) 2002 The libgnomecanvasmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gdkmm/pixbuf.h>
+#include <gtkmm/enums.h>
+#include <libgnomecanvasmm/item.h>
+#include <libgnomecanvas/gnome-canvas-pixbuf.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GnomeCanvasPixbuf GnomeCanvasPixbuf;
+typedef struct _GnomeCanvasPixbufClass GnomeCanvasPixbufClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gnome
+{
+
+namespace Canvas
+{ class Pixbuf_Class; } // namespace Canvas
+
+} // namespace Gnome
+namespace Gnome
+{
+
+namespace Canvas
+{
+
+
+class Pixbuf : public Item
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Pixbuf CppObjectType;
+  typedef Pixbuf_Class CppClassType;
+  typedef GnomeCanvasPixbuf BaseObjectType;
+  typedef GnomeCanvasPixbufClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~Pixbuf();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class Pixbuf_Class;
+  static CppClassType pixbuf_class_;
+
+  // noncopyable
+  Pixbuf(const Pixbuf&);
+  Pixbuf& operator=(const Pixbuf&);
+
+protected:
+  explicit Pixbuf(const Glib::ConstructParams& construct_params);
+  explicit Pixbuf(GnomeCanvasPixbuf* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GnomeCanvasPixbuf*       gobj()       { return reinterpret_cast<GnomeCanvasPixbuf*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GnomeCanvasPixbuf* gobj() const { return reinterpret_cast<GnomeCanvasPixbuf*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+private:
+
+public:
+  Pixbuf(Group& parent, double x, double y, const Glib::RefPtr<Gdk::Pixbuf>& image);
+  explicit Pixbuf(Group& parent);
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy< Glib::RefPtr<Gdk::Pixbuf> > property_pixbuf() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Pixbuf> > property_pixbuf() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<double> property_width() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<double> property_width() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_width_set() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_width_set() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_width_in_pixels() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_width_in_pixels() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<double> property_height() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<double> property_height() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_height_set() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_height_set() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_height_in_pixels() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_height_in_pixels() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<double> property_x() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<double> property_x() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_x_in_pixels() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_x_in_pixels() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<double> property_y() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<double> property_y() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_y_in_pixels() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_y_in_pixels() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Gtk::AnchorType> property_anchor() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Gtk::AnchorType> property_anchor() const;
+
+
+};
+
+} /* namespace Canvas */
+} /* namespace Gnome */
+
+namespace Glib
+{
+  /** @relates Gnome::Canvas::Pixbuf
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gnome::Canvas::Pixbuf* wrap(GnomeCanvasPixbuf* object, bool take_copy = false);
+}
+#endif /* _LIBGNOMECANVASMM_PIXBUF_H */
+
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/point.cc b/libs/libgnomecanvasmm/libgnomecanvasmm/point.cc
new file mode 100644
index 0000000000..051312b0c3
--- /dev/null
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/point.cc
@@ -0,0 +1,117 @@
+/* point.cc
+ * 
+ * Copyright (C) 1999 The gnomemm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <libgnomecanvasmm/point.h>
+
+namespace Gnome
+{
+
+namespace Art
+{
+
+Point::Point(const ArtPoint& artpoint)
+{
+  m_ArtPoint = artpoint;
+}
+  
+Point::Point(gdouble x /* = 0.0 */, gdouble y /* = 0.0 */)
+{
+  m_ArtPoint.x = x;
+  m_ArtPoint.y = y;
+}
+
+Point::Point(const Point& src)
+{
+  operator=(src);
+}
+
+Point& Point::operator=(const Point& src)
+{
+  m_ArtPoint = src.m_ArtPoint;
+  return *this;
+}
+
+Point::~Point()
+{
+}
+
+gdouble Point::get_x() const
+{
+  return m_ArtPoint.x; 
+}
+
+void Point::set_x(gdouble x)
+{
+  m_ArtPoint.x = x; 
+}
+
+gdouble Point::get_y() const
+{
+  return m_ArtPoint.y; 
+}
+
+void Point::set_y(gdouble y)
+{
+  m_ArtPoint.y = y;
+}
+  
+Point Point::operator+(const Point& p2)
+{
+  return Point(get_x() + p2.get_x(), get_y() + p2.get_y());
+}
+
+Point Point::operator-(const Point& p2)
+{
+  return Point(get_x() - p2.get_x(), get_y() - p2.get_y());
+}
+
+Point const & Point::operator+=(const Point& other)
+{
+  set_x(get_x() + other.get_x());
+  set_y(get_y() + other.get_y());
+  return *this;
+}
+
+Point const & Point::operator-=(const Point& other)
+{
+  set_x(get_x() - other.get_x());
+  set_y(get_y() - other.get_y());
+  return *this;
+}
+
+ArtPoint* Point::gobj()
+{
+  return &m_ArtPoint;
+}
+
+const ArtPoint* Point::gobj() const
+{
+  return &m_ArtPoint;
+}
+
+
+} //namespace Art
+
+} //namespace Gnome
+
+
+std::ostream& operator<<(std::ostream& out, const Gnome::Art::Point& p)
+{
+  return out << '(' << p.get_x() << ", " << p.get_y() << ')';
+}
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/point.h b/libs/libgnomecanvasmm/libgnomecanvasmm/point.h
new file mode 100644
index 0000000000..e548116073
--- /dev/null
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/point.h
@@ -0,0 +1,74 @@
+#ifndef _LIBGNOMECANVASMM_POINT_H
+#define _LIBGNOMECANVASMM_POINT_H
+
+// -*- C++ -*-
+/* $Id$ */
+
+/* point.h
+ * 
+ * Copyright (C) 1999 The gnomemm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <libgnomecanvas/gnome-canvas.h>
+//#include <libgnomecanvasmm/types.h>
+#include <iostream>
+
+namespace Gnome
+{
+
+namespace Art
+{
+
+/** Wrapper for ArtPoint struct.
+ * Used by AffineTrans and CanvasPoints.
+ */
+class Point
+{
+public:
+  Point(gdouble x = 0.0, gdouble y = 0.0);
+  Point(const ArtPoint& artpoint);
+  Point(const Point& src);
+  Point& operator=(const Point& src);
+  ~Point();
+
+  gdouble get_x() const;
+  void set_x(gdouble x);
+  gdouble get_y() const;
+  void set_y(gdouble y);
+  
+  Point operator+(const Point& p2);
+  Point operator-(const Point& p2);
+  Point const & operator+=(const Point& other);
+  Point const & operator-=(const Point& other);
+
+  ArtPoint* gobj();
+  const ArtPoint* gobj() const;
+
+  protected:
+    //GnomeCanvasPoints uses arrays of double, 2 at a time, which is the same as a set of ArtPoints
+    //because an ArtPoint struct only has 2 double members.
+    ArtPoint m_ArtPoint;
+};
+
+} //namespace Art
+
+} //namespace Gnome
+
+std::ostream& operator<<(std::ostream& out, const Gnome::Art::Point& p);
+
+#endif /* _LIBGNOMECANVASMM_POINT_H */
+
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/polygon.cc b/libs/libgnomecanvasmm/libgnomecanvasmm/polygon.cc
new file mode 100644
index 0000000000..08eb1b60bc
--- /dev/null
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/polygon.cc
@@ -0,0 +1,156 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <libgnomecanvasmm/polygon.h>
+#include <libgnomecanvasmm/private/polygon_p.h>
+
+/* $Id$ */
+
+/* polygon.ccg
+ * 
+ * Copyright (C) 1999 The Gtk-- Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+namespace Gnome
+{
+
+namespace Canvas
+{
+
+Polygon::Polygon(Group& parent,const Points& points)
+  : Shape(GNOME_CANVAS_SHAPE(g_object_new(get_type(),0)))
+{
+  item_construct(parent);
+  property_points().set_value(points);
+}
+
+Polygon::Polygon(Group& parent)
+    : Shape(GNOME_CANVAS_SHAPE(g_object_new(get_type(),0)))
+{
+  item_construct(parent);
+}
+
+} /* namespace Canvas */
+} /* namespace Gnome */
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gnome::Canvas::Polygon* wrap(GnomeCanvasPolygon* object, bool take_copy)
+{
+  return dynamic_cast<Gnome::Canvas::Polygon *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gnome
+{
+
+namespace Canvas
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& Polygon_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &Polygon_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gnome_canvas_polygon_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void Polygon_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* Polygon_Class::wrap_new(GObject* o)
+{
+  return manage(new Polygon((GnomeCanvasPolygon*)(o)));
+
+}
+
+
+/* The implementation: */
+
+Polygon::Polygon(const Glib::ConstructParams& construct_params)
+:
+  Shape(construct_params)
+{
+  }
+
+Polygon::Polygon(GnomeCanvasPolygon* castitem)
+:
+  Shape((GnomeCanvasShape*)(castitem))
+{
+  }
+
+Polygon::~Polygon()
+{
+  destroy_();
+}
+
+Polygon::CppClassType Polygon::polygon_class_; // initialize static member
+
+GType Polygon::get_type()
+{
+  return polygon_class_.init().get_type();
+}
+
+GType Polygon::get_base_type()
+{
+  return gnome_canvas_polygon_get_type();
+}
+
+
+Glib::PropertyProxy<Points> Polygon::property_points() 
+{
+  return Glib::PropertyProxy<Points>(this, "points");
+}
+
+Glib::PropertyProxy_ReadOnly<Points> Polygon::property_points() const
+{
+  return Glib::PropertyProxy_ReadOnly<Points>(this, "points");
+}
+
+
+} // namespace Canvas
+
+} // namespace Gnome
+
+
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/polygon.h b/libs/libgnomecanvasmm/libgnomecanvasmm/polygon.h
new file mode 100644
index 0000000000..1d6dad5e55
--- /dev/null
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/polygon.h
@@ -0,0 +1,144 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _LIBGNOMECANVASMM_POLYGON_H
+#define _LIBGNOMECANVASMM_POLYGON_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+
+/* polygon.hg
+ * 
+ * Copyright (C) 1999 The Gtk-- Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <libgnomecanvasmm/shape.h>
+#include <libgnomecanvasmm/line.h>
+#include <libgnomecanvas/gnome-canvas-polygon.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GnomeCanvasPolygon GnomeCanvasPolygon;
+typedef struct _GnomeCanvasPolygonClass GnomeCanvasPolygonClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gnome
+{
+
+namespace Canvas
+{ class Polygon_Class; } // namespace Canvas
+
+} // namespace Gnome
+namespace Gnome
+{
+
+namespace Canvas
+{
+
+
+class Polygon : public Shape
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Polygon CppObjectType;
+  typedef Polygon_Class CppClassType;
+  typedef GnomeCanvasPolygon BaseObjectType;
+  typedef GnomeCanvasPolygonClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~Polygon();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class Polygon_Class;
+  static CppClassType polygon_class_;
+
+  // noncopyable
+  Polygon(const Polygon&);
+  Polygon& operator=(const Polygon&);
+
+protected:
+  explicit Polygon(const Glib::ConstructParams& construct_params);
+  explicit Polygon(GnomeCanvasPolygon* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GnomeCanvasPolygon*       gobj()       { return reinterpret_cast<GnomeCanvasPolygon*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GnomeCanvasPolygon* gobj() const { return reinterpret_cast<GnomeCanvasPolygon*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+private:
+
+public:
+  Polygon(Group& parent, const Points& points);
+  explicit Polygon(Group& parent);
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Points> property_points() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Points> property_points() const;
+
+
+};
+
+} /* namespace Canvas */
+} /* namespace Gnome */
+
+
+namespace Glib
+{
+  /** @relates Gnome::Canvas::Polygon
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gnome::Canvas::Polygon* wrap(GnomeCanvasPolygon* object, bool take_copy = false);
+}
+#endif /* _LIBGNOMECANVASMM_POLYGON_H */
+
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/private/bpath_p.h b/libs/libgnomecanvasmm/libgnomecanvasmm/private/bpath_p.h
new file mode 100644
index 0000000000..4c6d727306
--- /dev/null
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/private/bpath_p.h
@@ -0,0 +1,49 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _LIBGNOMECANVASMM_BPATH_P_H
+#define _LIBGNOMECANVASMM_BPATH_P_H
+#include <libgnomecanvasmm/private/shape_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gnome
+{
+
+namespace Canvas
+{
+
+class Bpath_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Bpath CppObjectType;
+  typedef GnomeCanvasBpath BaseObjectType;
+  typedef GnomeCanvasBpathClass BaseClassType;
+  typedef Shape_Class CppClassParent;
+  typedef GnomeCanvasShapeClass BaseClassParent;
+
+  friend class Bpath;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Canvas
+
+} // namespace Gnome
+
+#endif /* _LIBGNOMECANVASMM_BPATH_P_H */
+
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/private/canvas_p.h b/libs/libgnomecanvasmm/libgnomecanvasmm/private/canvas_p.h
new file mode 100644
index 0000000000..48b08937c5
--- /dev/null
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/private/canvas_p.h
@@ -0,0 +1,52 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _LIBGNOMECANVASMM_CANVAS_P_H
+#define _LIBGNOMECANVASMM_CANVAS_P_H
+#include <gtkmm/private/layout_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gnome
+{
+
+namespace Canvas
+{
+
+class Canvas_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Canvas CppObjectType;
+  typedef GnomeCanvas BaseObjectType;
+  typedef GnomeCanvasClass BaseClassType;
+  typedef Gtk::Layout_Class CppClassParent;
+  typedef GtkLayoutClass BaseClassParent;
+
+  friend class Canvas;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+  static void draw_background_callback(GnomeCanvas* self, GdkDrawable* p0, gint p1, gint p2, gint p3, gint p4);
+  static void render_background_callback(GnomeCanvas* self, GnomeCanvasBuf* p0);
+
+  //Callbacks (virtual functions):
+  static void request_update_vfunc_callback(GnomeCanvas* self);
+};
+
+
+} // namespace Canvas
+
+} // namespace Gnome
+
+#endif /* _LIBGNOMECANVASMM_CANVAS_P_H */
+
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/private/ellipse_p.h b/libs/libgnomecanvasmm/libgnomecanvasmm/private/ellipse_p.h
new file mode 100644
index 0000000000..513b1a945c
--- /dev/null
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/private/ellipse_p.h
@@ -0,0 +1,49 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _LIBGNOMECANVASMM_ELLIPSE_P_H
+#define _LIBGNOMECANVASMM_ELLIPSE_P_H
+#include <libgnomecanvasmm/private/rect-ellipse_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gnome
+{
+
+namespace Canvas
+{
+
+class Ellipse_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Ellipse CppObjectType;
+  typedef GnomeCanvasEllipse BaseObjectType;
+  typedef GnomeCanvasEllipseClass BaseClassType;
+  typedef RectEllipse_Class CppClassParent;
+  typedef GnomeCanvasREClass BaseClassParent;
+
+  friend class Ellipse;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Canvas
+
+} // namespace Gnome
+
+#endif /* _LIBGNOMECANVASMM_ELLIPSE_P_H */
+
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/private/group_p.h b/libs/libgnomecanvasmm/libgnomecanvasmm/private/group_p.h
new file mode 100644
index 0000000000..95a2ecff44
--- /dev/null
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/private/group_p.h
@@ -0,0 +1,49 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _LIBGNOMECANVASMM_GROUP_P_H
+#define _LIBGNOMECANVASMM_GROUP_P_H
+#include <libgnomecanvasmm/private/item_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gnome
+{
+
+namespace Canvas
+{
+
+class Group_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Group CppObjectType;
+  typedef GnomeCanvasGroup BaseObjectType;
+  typedef GnomeCanvasGroupClass BaseClassType;
+  typedef Item_Class CppClassParent;
+  typedef GnomeCanvasItemClass BaseClassParent;
+
+  friend class Group;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Canvas
+
+} // namespace Gnome
+
+#endif /* _LIBGNOMECANVASMM_GROUP_P_H */
+
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/private/item_p.h b/libs/libgnomecanvasmm/libgnomecanvasmm/private/item_p.h
new file mode 100644
index 0000000000..d898eb8304
--- /dev/null
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/private/item_p.h
@@ -0,0 +1,60 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _LIBGNOMECANVASMM_ITEM_P_H
+#define _LIBGNOMECANVASMM_ITEM_P_H
+#include <gtkmm/private/object_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gnome
+{
+
+namespace Canvas
+{
+
+class Item_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Item CppObjectType;
+  typedef GnomeCanvasItem BaseObjectType;
+  typedef GnomeCanvasItemClass BaseClassType;
+  typedef Gtk::Object_Class CppClassParent;
+  typedef GtkObjectClass BaseClassParent;
+
+  friend class Item;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+  static gboolean event_callback(GnomeCanvasItem* self, GdkEvent* p0);
+
+  //Callbacks (virtual functions):
+  static void update_vfunc_callback(GnomeCanvasItem* self, double* affine, ArtSVP* clip_path, int flags);
+  static void realize_vfunc_callback(GnomeCanvasItem* self);
+  static void unrealize_vfunc_callback(GnomeCanvasItem* self);
+  static void map_vfunc_callback(GnomeCanvasItem* self);
+  static void unmap_vfunc_callback(GnomeCanvasItem* self);
+  static ArtUta* coverage_vfunc_callback(GnomeCanvasItem* self);
+  static void draw_vfunc_callback(GnomeCanvasItem* self, GdkDrawable* drawable, int x, int y, int width, int height);
+  static void render_vfunc_callback(GnomeCanvasItem* self, GnomeCanvasBuf* buf);
+  static double point_vfunc_callback(GnomeCanvasItem* self, double x, double y, int cx, int cy, GnomeCanvasItem** actual_item);
+  static void bounds_vfunc_callback(GnomeCanvasItem* self, double* x1, double* y1, double* x2, double* y2);
+};
+
+
+} // namespace Canvas
+
+} // namespace Gnome
+
+#endif /* _LIBGNOMECANVASMM_ITEM_P_H */
+
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/private/line_p.h b/libs/libgnomecanvasmm/libgnomecanvasmm/private/line_p.h
new file mode 100644
index 0000000000..819ad6ee7c
--- /dev/null
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/private/line_p.h
@@ -0,0 +1,49 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _LIBGNOMECANVASMM_LINE_P_H
+#define _LIBGNOMECANVASMM_LINE_P_H
+#include <libgnomecanvasmm/private/item_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gnome
+{
+
+namespace Canvas
+{
+
+class Line_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Line CppObjectType;
+  typedef GnomeCanvasLine BaseObjectType;
+  typedef GnomeCanvasLineClass BaseClassType;
+  typedef Item_Class CppClassParent;
+  typedef GnomeCanvasItemClass BaseClassParent;
+
+  friend class Line;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Canvas
+
+} // namespace Gnome
+
+#endif /* _LIBGNOMECANVASMM_LINE_P_H */
+
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/private/path-def_p.h b/libs/libgnomecanvasmm/libgnomecanvasmm/private/path-def_p.h
new file mode 100644
index 0000000000..b7ccc3f278
--- /dev/null
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/private/path-def_p.h
@@ -0,0 +1,6 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _LIBGNOMECANVASMM_PATH_DEF_P_H
+#define _LIBGNOMECANVASMM_PATH_DEF_P_H
+#endif /* _LIBGNOMECANVASMM_PATH_DEF_P_H */
+
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/private/pixbuf_p.h b/libs/libgnomecanvasmm/libgnomecanvasmm/private/pixbuf_p.h
new file mode 100644
index 0000000000..54e464677a
--- /dev/null
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/private/pixbuf_p.h
@@ -0,0 +1,49 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _LIBGNOMECANVASMM_PIXBUF_P_H
+#define _LIBGNOMECANVASMM_PIXBUF_P_H
+#include <libgnomecanvasmm/private/item_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gnome
+{
+
+namespace Canvas
+{
+
+class Pixbuf_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Pixbuf CppObjectType;
+  typedef GnomeCanvasPixbuf BaseObjectType;
+  typedef GnomeCanvasPixbufClass BaseClassType;
+  typedef Item_Class CppClassParent;
+  typedef GnomeCanvasItemClass BaseClassParent;
+
+  friend class Pixbuf;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Canvas
+
+} // namespace Gnome
+
+#endif /* _LIBGNOMECANVASMM_PIXBUF_P_H */
+
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/private/polygon_p.h b/libs/libgnomecanvasmm/libgnomecanvasmm/private/polygon_p.h
new file mode 100644
index 0000000000..2ca067cf7b
--- /dev/null
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/private/polygon_p.h
@@ -0,0 +1,49 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _LIBGNOMECANVASMM_POLYGON_P_H
+#define _LIBGNOMECANVASMM_POLYGON_P_H
+#include <libgnomecanvasmm/private/shape_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gnome
+{
+
+namespace Canvas
+{
+
+class Polygon_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Polygon CppObjectType;
+  typedef GnomeCanvasPolygon BaseObjectType;
+  typedef GnomeCanvasPolygonClass BaseClassType;
+  typedef Shape_Class CppClassParent;
+  typedef GnomeCanvasShapeClass BaseClassParent;
+
+  friend class Polygon;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Canvas
+
+} // namespace Gnome
+
+#endif /* _LIBGNOMECANVASMM_POLYGON_P_H */
+
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/private/rect-ellipse_p.h b/libs/libgnomecanvasmm/libgnomecanvasmm/private/rect-ellipse_p.h
new file mode 100644
index 0000000000..73913352bb
--- /dev/null
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/private/rect-ellipse_p.h
@@ -0,0 +1,49 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _LIBGNOMECANVASMM_RECT_ELLIPSE_P_H
+#define _LIBGNOMECANVASMM_RECT_ELLIPSE_P_H
+#include <libgnomecanvasmm/private/shape_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gnome
+{
+
+namespace Canvas
+{
+
+class RectEllipse_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef RectEllipse CppObjectType;
+  typedef GnomeCanvasRE BaseObjectType;
+  typedef GnomeCanvasREClass BaseClassType;
+  typedef Shape_Class CppClassParent;
+  typedef GnomeCanvasShapeClass BaseClassParent;
+
+  friend class RectEllipse;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Canvas
+
+} // namespace Gnome
+
+#endif /* _LIBGNOMECANVASMM_RECT_ELLIPSE_P_H */
+
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/private/rect_p.h b/libs/libgnomecanvasmm/libgnomecanvasmm/private/rect_p.h
new file mode 100644
index 0000000000..a42c84fd15
--- /dev/null
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/private/rect_p.h
@@ -0,0 +1,49 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _LIBGNOMECANVASMM_RECT_P_H
+#define _LIBGNOMECANVASMM_RECT_P_H
+#include <libgnomecanvasmm/private/rect-ellipse_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gnome
+{
+
+namespace Canvas
+{
+
+class Rect_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Rect CppObjectType;
+  typedef GnomeCanvasRect BaseObjectType;
+  typedef GnomeCanvasRectClass BaseClassType;
+  typedef RectEllipse_Class CppClassParent;
+  typedef GnomeCanvasREClass BaseClassParent;
+
+  friend class Rect;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Canvas
+
+} // namespace Gnome
+
+#endif /* _LIBGNOMECANVASMM_RECT_P_H */
+
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/private/rich-text_p.h b/libs/libgnomecanvasmm/libgnomecanvasmm/private/rich-text_p.h
new file mode 100644
index 0000000000..90fa63a557
--- /dev/null
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/private/rich-text_p.h
@@ -0,0 +1,50 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _LIBGNOMECANVASMM_RICH_TEXT_P_H
+#define _LIBGNOMECANVASMM_RICH_TEXT_P_H
+#include <libgnomecanvasmm/private/item_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gnome
+{
+
+namespace Canvas
+{
+
+class RichText_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef RichText CppObjectType;
+  typedef GnomeCanvasRichText BaseObjectType;
+  typedef GnomeCanvasRichTextClass BaseClassType;
+  typedef Item_Class CppClassParent;
+  typedef GnomeCanvasItemClass BaseClassParent;
+
+  friend class RichText;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+  static void tag_changed_callback(GnomeCanvasRichText* self, GtkTextTag* tag);
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Canvas
+
+} // namespace Gnome
+
+#endif /* _LIBGNOMECANVASMM_RICH_TEXT_P_H */
+
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/private/shape_p.h b/libs/libgnomecanvasmm/libgnomecanvasmm/private/shape_p.h
new file mode 100644
index 0000000000..f0fac4d6f2
--- /dev/null
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/private/shape_p.h
@@ -0,0 +1,49 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _LIBGNOMECANVASMM_SHAPE_P_H
+#define _LIBGNOMECANVASMM_SHAPE_P_H
+#include <libgnomecanvasmm/private/item_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gnome
+{
+
+namespace Canvas
+{
+
+class Shape_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Shape CppObjectType;
+  typedef GnomeCanvasShape BaseObjectType;
+  typedef GnomeCanvasShapeClass BaseClassType;
+  typedef Item_Class CppClassParent;
+  typedef GnomeCanvasItemClass BaseClassParent;
+
+  friend class Shape;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Canvas
+
+} // namespace Gnome
+
+#endif /* _LIBGNOMECANVASMM_SHAPE_P_H */
+
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/private/text_p.h b/libs/libgnomecanvasmm/libgnomecanvasmm/private/text_p.h
new file mode 100644
index 0000000000..f15e8e5a50
--- /dev/null
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/private/text_p.h
@@ -0,0 +1,49 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _LIBGNOMECANVASMM_TEXT_P_H
+#define _LIBGNOMECANVASMM_TEXT_P_H
+#include <libgnomecanvasmm/private/item_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gnome
+{
+
+namespace Canvas
+{
+
+class Text_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Text CppObjectType;
+  typedef GnomeCanvasText BaseObjectType;
+  typedef GnomeCanvasTextClass BaseClassType;
+  typedef Item_Class CppClassParent;
+  typedef GnomeCanvasItemClass BaseClassParent;
+
+  friend class Text;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Canvas
+
+} // namespace Gnome
+
+#endif /* _LIBGNOMECANVASMM_TEXT_P_H */
+
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/private/widget_p.h b/libs/libgnomecanvasmm/libgnomecanvasmm/private/widget_p.h
new file mode 100644
index 0000000000..22fede33de
--- /dev/null
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/private/widget_p.h
@@ -0,0 +1,49 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _LIBGNOMECANVASMM_WIDGET_P_H
+#define _LIBGNOMECANVASMM_WIDGET_P_H
+#include <libgnomecanvasmm/private/item_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gnome
+{
+
+namespace Canvas
+{
+
+class Widget_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Widget CppObjectType;
+  typedef GnomeCanvasWidget BaseObjectType;
+  typedef GnomeCanvasWidgetClass BaseClassType;
+  typedef Item_Class CppClassParent;
+  typedef GnomeCanvasItemClass BaseClassParent;
+
+  friend class Widget;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Canvas
+
+} // namespace Gnome
+
+#endif /* _LIBGNOMECANVASMM_WIDGET_P_H */
+
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/properties.cc b/libs/libgnomecanvasmm/libgnomecanvasmm/properties.cc
new file mode 100644
index 0000000000..f786e57836
--- /dev/null
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/properties.cc
@@ -0,0 +1,238 @@
+// -*- c++ -*-
+/* $Id$ */
+
+/* properties.cc
+ *
+ * Copyright (C) 2002 The Free Software Foundation
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <libgnomecanvasmm/properties.h>
+
+namespace Gnome
+{
+
+namespace Canvas
+{
+
+namespace Properties
+{
+
+PropertyBase::PropertyBase(const char* name)
+: name_(name)
+{}
+
+PropertyBase::~PropertyBase()
+{}
+
+const char* PropertyBase::get_name() const
+{
+  return name_;
+}
+
+/////////////////////////////
+// Property<Gdk::Color>
+
+Property<Gdk::Color>::Property(const char* name, const Gdk::Color& value) :
+  PropertyBase(name),
+  value_(value),
+  value_gobj_used_(true),
+  value_string_used_(false),
+  value_rgba_(0)
+{}
+
+Property<Gdk::Color>::Property(const char* name, const Glib::ustring& color) :
+  PropertyBase(name),
+  value_gobj_used_(false),
+  value_string_(color),
+  value_string_used_ (true),
+  value_rgba_(0)
+{}
+
+Property<Gdk::Color>::Property(const char* name, const guint& rgba_color) :
+  PropertyBase(name),
+  value_gobj_used_(false),
+  value_string_used_(false),
+  value_rgba_(rgba_color)
+{}
+
+void Property<Gdk::Color>::set_value_in_object(Glib::Object& object) const
+{
+  //Set the appropriate property name with the appropriately-typed value:
+  if(value_string_used_) {
+    
+    Glib::PropertyProxy<Glib::ustring> proxy(&object, get_name());
+    if (value_string_ == "")
+      proxy.reset_value ();
+    else
+      proxy.set_value(value_string_);
+
+  } else if(value_gobj_used_) {
+    
+    Glib::PropertyProxy<Gdk::Color> proxy(&object, get_name());
+    proxy.set_value(value_);
+
+  } else {
+    
+    Glib::PropertyProxy<guint> proxy(&object, get_name());
+    proxy.set_value(value_rgba_);
+  }
+}
+
+/////////////////////////////
+// Property<Pango::FontDescription>
+Property<Pango::FontDescription>::Property(const char* name, const Pango::FontDescription& value) :
+  PropertyBase(name),
+  value_(value)
+{}
+
+Property<Pango::FontDescription>::Property(const char* name, const Glib::ustring& font) :
+  PropertyBase(name),
+  value_(0),
+  value_string_(font)
+{}
+
+void Property<Pango::FontDescription>::set_value_in_object(Glib::Object& object) const
+{
+  if(value_string_.size())
+  {
+    Glib::PropertyProxy<Glib::ustring> proxy(&object, get_name());
+    proxy.set_value(value_string_);
+  }
+  else
+  {
+    Glib::PropertyProxy<Pango::FontDescription> proxy(&object, get_name());
+    proxy.set_value(value_);
+  }
+}
+
+
+/////////////////////////////
+// Property< Glib::RefPtr<Gdk::Bitmap> >
+Property< Glib::RefPtr<Gdk::Bitmap> >::Property(const char* name, const Glib::RefPtr<Gdk::Bitmap>& value)
+  : PropertyBase(name), 
+    value_(value)
+{}
+
+void Property< Glib::RefPtr<Gdk::Bitmap> >::set_value_in_object(Glib::Object& object) const
+{
+  Glib::PropertyProxy< Glib::RefPtr<Gdk::Bitmap> > proxy(&object, get_name());
+  proxy.set_value(value_);
+}
+
+
+font::font(const Pango::FontDescription& v)
+  : Property<Pango::FontDescription>("font-desc", v)
+{}
+
+font::font(const Glib::ustring& v)
+  : Property<Pango::FontDescription>("font", v)
+{}
+
+fill_color::fill_color(const Gdk::Color& v)
+  : Property<Gdk::Color>("fill_color_gdk",v)
+{}
+
+fill_color::fill_color(const Glib::ustring& v)
+  : Property<Gdk::Color>("fill_color",v)
+{}
+
+outline_color::outline_color(const Gdk::Color& v)
+  : Property<Gdk::Color>("outline_color_gdk", v)
+{}
+
+outline_color::outline_color(const Glib::ustring& v)
+  : Property<Gdk::Color>("outline_color", v)
+{}
+
+// GNOMEMM_PROPERTY_IMPL(C++ name, C property name, C++ type)
+#define GNOMEMM_PROPERTY_IMPL(N,N2,T) \
+N::N(const T& v) \
+  : Property<T >(#N2, v) \
+{}
+
+// CanvasLine
+GNOMEMM_PROPERTY_IMPL(arrow_shape_a,arrow_shape_a,double)
+GNOMEMM_PROPERTY_IMPL(arrow_shape_b,arrow_shape_b,double)
+GNOMEMM_PROPERTY_IMPL(arrow_shape_c,arrow_shape_c,double)
+GNOMEMM_PROPERTY_IMPL(cap_style,cap_style,Gdk::CapStyle)
+GNOMEMM_PROPERTY_IMPL(first_arrowhead,first_arrowhead,bool)
+GNOMEMM_PROPERTY_IMPL(join_style,join_style,Gdk::JoinStyle)
+GNOMEMM_PROPERTY_IMPL(last_arrowhead,last_arrowhead,bool)
+GNOMEMM_PROPERTY_IMPL(line_style,line_style,Gdk::LineStyle)
+GNOMEMM_PROPERTY_IMPL(smooth,smooth,bool)
+GNOMEMM_PROPERTY_IMPL(spline_steps,spline_steps,guint)
+
+// CanvasText
+GNOMEMM_PROPERTY_IMPL(clip,clip,bool)
+GNOMEMM_PROPERTY_IMPL(clip_height,clip_height,double)
+GNOMEMM_PROPERTY_IMPL(clip_width,clip_width,double)
+GNOMEMM_PROPERTY_IMPL(wrap_mode,wrap_mode,Gtk::WrapMode)
+GNOMEMM_PROPERTY_IMPL(justification,justification,Gtk::Justification)
+GNOMEMM_PROPERTY_IMPL(direction,direction,Gtk::DirectionType)
+GNOMEMM_PROPERTY_IMPL(text_height,text_height,double)
+GNOMEMM_PROPERTY_IMPL(text_width,text_width,double)
+GNOMEMM_PROPERTY_IMPL(x_offset,x_offset,double)
+GNOMEMM_PROPERTY_IMPL(y_offset,y_offset,double)
+GNOMEMM_PROPERTY_IMPL(text,text,Glib::ustring)
+GNOMEMM_PROPERTY_IMPL(markup,markup,Glib::ustring)
+GNOMEMM_PROPERTY_IMPL(editable,editable,bool)
+GNOMEMM_PROPERTY_IMPL(visible,visible,bool)
+GNOMEMM_PROPERTY_IMPL(cursor_visible,cursor_visible,bool)
+GNOMEMM_PROPERTY_IMPL(cursor_blink,cursor_blink,bool)
+GNOMEMM_PROPERTY_IMPL(grow_height,grow_height,bool)
+GNOMEMM_PROPERTY_IMPL(pixels_above_lines,pixels_above_lines,int)
+GNOMEMM_PROPERTY_IMPL(pixels_below_lines,pixels_below_lines,int)
+GNOMEMM_PROPERTY_IMPL(pixels_inside_wrap,pixels_inside_wrap,int)
+GNOMEMM_PROPERTY_IMPL(left_margin,left_margin,int)
+GNOMEMM_PROPERTY_IMPL(right_margin,right_margin,int)
+GNOMEMM_PROPERTY_IMPL(indent,indent,int)
+
+// CanvasWidget
+GNOMEMM_PROPERTY_IMPL(size_pixels,size_pixels,bool)
+
+// CanvasImage, CanvasWidget
+GNOMEMM_PROPERTY_IMPL(height,height,double)
+GNOMEMM_PROPERTY_IMPL(width,width,double)
+
+// CanvasRect, CanvasEllipse
+GNOMEMM_PROPERTY_IMPL(x1,x1,double)
+GNOMEMM_PROPERTY_IMPL(x2,x2,double)
+GNOMEMM_PROPERTY_IMPL(y1,y1,double)
+GNOMEMM_PROPERTY_IMPL(y2,y2,double)
+
+// CanvasImage, CanvasText, CanvasWidget
+GNOMEMM_PROPERTY_IMPL(anchor,anchor,Gtk::AnchorType)
+
+// CanvasPolygon, CanvasRect, CanvasEllipse
+GNOMEMM_PROPERTY_IMPL(outline_stipple,outline_stipple,Glib::RefPtr<Gdk::Bitmap>)
+GNOMEMM_PROPERTY_IMPL(wind,wind,guint)
+GNOMEMM_PROPERTY_IMPL(miterlimit,miterlimit,double)
+
+// CanvasLine, CanvasPolygon, CanvasRect, CanvasEllipse
+GNOMEMM_PROPERTY_IMPL(width_pixels,width_pixels,guint)
+GNOMEMM_PROPERTY_IMPL(width_units,width_units,double)
+
+// CanvasGroup, CanvasImage, CanvasText, CanvasWidget
+GNOMEMM_PROPERTY_IMPL(x,x,double)
+GNOMEMM_PROPERTY_IMPL(y,y,double)
+
+// CanvasLine, CanvasPolygon, CanvasRect, CanvasEllipse, CanvasText
+GNOMEMM_PROPERTY_IMPL(fill_stipple,fill_stipple,Glib::RefPtr<Gdk::Bitmap>)
+
+} /* namespace Properties */
+} /* namespace Canvas */
+} /* namespace Gnome */
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/properties.h b/libs/libgnomecanvasmm/libgnomecanvasmm/properties.h
new file mode 100644
index 0000000000..c25025f18d
--- /dev/null
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/properties.h
@@ -0,0 +1,248 @@
+#ifndef _LIBGNOMECANVASMM_PROPERTIES_H_
+#define _LIBGNOMECANVASMM_PROPERTIES_H_
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* properties.h
+ *
+ * Copyright (C) 1999-2002 The Free Software Foundation
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+//#include <gtk/gtkpacker.h> //For GtkAnchorType.
+
+
+#include <glibmm/propertyproxy.h>
+#include <gdkmm/color.h>
+#include <gdkmm/bitmap.h>
+#include <pangomm/fontdescription.h>
+#include <gtkmm/enums.h>
+
+namespace Gnome
+{
+
+namespace Canvas
+{
+
+namespace Properties
+{
+
+class PropertyBase
+{
+public:
+  PropertyBase(const char* name);
+  ~PropertyBase();
+
+  const char* get_name() const;
+
+protected:
+  const char* name_;
+};
+
+template <class T_Value>
+class Property : public PropertyBase
+{
+public:
+  Property(const char* name, const T_Value& value)
+  : PropertyBase(name), value_(value)
+  {}
+
+  void set_value_in_object(Glib::Object& object) const
+  {
+    Glib::PropertyProxy<T_Value> proxy(&object, get_name());
+    proxy.set_value(value_);
+  }
+
+protected:
+  T_Value value_;
+};
+
+
+/** Allow use of << operator on objects:
+  * For instance:
+  * canvasgroup << Gnome::Canvas::CanvasHelpers::x(2);
+  */
+template <class O, class T>
+O& operator << (O& object, const Property<T>& property)
+{
+  property.set_value_in_object(object);
+  return object;
+}
+
+/********* specializations *********/
+
+//Colors can be specified with a string or a Gdk::Color, or an rgba guint.
+template<>
+class Property<Gdk::Color> : public PropertyBase
+{
+public:
+  Property(const char* name, const Gdk::Color& value);
+  Property(const char* name, const Glib::ustring& color);  
+  Property(const char* name, const guint& rgba_color);
+
+  void set_value_in_object(Glib::Object& object) const;
+
+protected:
+  Gdk::Color value_;
+  bool value_gobj_used_; //Whether the Gdk::Value was intialised in the constructor.
+  Glib::ustring value_string_;
+  bool value_string_used_;
+  guint value_rgba_;
+};
+
+//Font can be specified with a string or a Pango::FontDescription.
+template<>
+class Property<Pango::FontDescription> : public PropertyBase
+{
+public:
+  Property(const char* name, const Pango::FontDescription& value);
+  Property(const char* name, const Glib::ustring& font);
+
+  void set_value_in_object(Glib::Object& object) const;
+
+protected:
+  Pango::FontDescription value_;
+  Glib::ustring value_string_;
+};
+
+
+//We now define some specific properties.
+//Some of these are unusual, so we define them manually.
+//Others are regular so we define them with a macro:
+
+
+class font : public Property<Pango::FontDescription>  //Used by CanvasText.
+{
+public:
+  font(const Pango::FontDescription& v);
+
+  font(const Glib::ustring& v);
+};
+
+template<>
+class Property< Glib::RefPtr<Gdk::Bitmap> > : public PropertyBase
+{
+public:
+  Property(const char* name, const Glib::RefPtr<Gdk::Bitmap>& value);
+
+  void set_value_in_object(Glib::Object& object) const;
+
+protected:
+  Glib::RefPtr<Gdk::Bitmap> value_;
+};
+
+class fill_color : public Property<Gdk::Color>
+{
+public:
+  fill_color(const Gdk::Color& v);
+
+  fill_color(const Glib::ustring& v);
+};
+
+class outline_color : public Property<Gdk::Color>
+{
+public:
+  outline_color(const Gdk::Color& v);
+
+  outline_color(const Glib::ustring& v);
+};
+
+
+// GNOMEMM_PROPERTY(C++ name, C property name, C++ type)
+#define GNOMEMM_PROPERTY(N,N2,T) \
+class N : public Property<T > \
+{ \
+public: \
+  N(const T& v); \
+};
+
+
+// CanvasLine
+GNOMEMM_PROPERTY(arrow_shape_a,arrow_shape_a,double)
+GNOMEMM_PROPERTY(arrow_shape_b,arrow_shape_b,double)
+GNOMEMM_PROPERTY(arrow_shape_c,arrow_shape_c,double)
+GNOMEMM_PROPERTY(cap_style,cap_style,Gdk::CapStyle)
+GNOMEMM_PROPERTY(first_arrowhead,first_arrowhead,bool)
+GNOMEMM_PROPERTY(join_style,join_style,Gdk::JoinStyle)
+GNOMEMM_PROPERTY(last_arrowhead,last_arrowhead,bool)
+GNOMEMM_PROPERTY(line_style,line_style,Gdk::LineStyle)
+GNOMEMM_PROPERTY(smooth,smooth,bool)
+GNOMEMM_PROPERTY(spline_steps,spline_steps,guint)
+
+// CanvasText
+GNOMEMM_PROPERTY(clip,clip,bool)
+GNOMEMM_PROPERTY(clip_height,clip_height,double)
+GNOMEMM_PROPERTY(clip_width,clip_width,double)
+GNOMEMM_PROPERTY(justification,justification,Gtk::Justification)
+GNOMEMM_PROPERTY(direction,direction,Gtk::DirectionType)
+GNOMEMM_PROPERTY(wrap_mode,wrap_mode,Gtk::WrapMode)
+GNOMEMM_PROPERTY(text_height,text_height,double)
+GNOMEMM_PROPERTY(text_width,text_width,double)
+GNOMEMM_PROPERTY(x_offset,x_offset,double)
+GNOMEMM_PROPERTY(y_offset,y_offset,double)
+GNOMEMM_PROPERTY(text,text,Glib::ustring)
+GNOMEMM_PROPERTY(markup,markup,Glib::ustring)
+GNOMEMM_PROPERTY(editable,editable,bool)
+GNOMEMM_PROPERTY(visible,visible,bool)
+GNOMEMM_PROPERTY(cursor_visible,cursor_visible,bool)
+GNOMEMM_PROPERTY(cursor_blink,cursor_blink,bool)
+GNOMEMM_PROPERTY(grow_height,grow_height,bool)
+GNOMEMM_PROPERTY(pixels_above_lines,pixels_above_lines,int)
+GNOMEMM_PROPERTY(pixels_below_lines,pixels_below_lines,int)
+GNOMEMM_PROPERTY(pixels_inside_wrap,pixels_inside_wrap,int)
+GNOMEMM_PROPERTY(left_margin,left_margin,int)
+GNOMEMM_PROPERTY(right_margin,right_margin,int)
+GNOMEMM_PROPERTY(indent,indent,int)
+
+// CanvasWidget
+GNOMEMM_PROPERTY(size_pixels,size_pixels,bool)
+
+// CanvasImage, CanvasWidget
+GNOMEMM_PROPERTY(height,height,double)
+GNOMEMM_PROPERTY(width,width,double)
+
+// CanvasRect, CanvasEllipse
+GNOMEMM_PROPERTY(x1,x1,double)
+GNOMEMM_PROPERTY(x2,x2,double)
+GNOMEMM_PROPERTY(y1,y1,double)
+GNOMEMM_PROPERTY(y2,y2,double)
+
+// CanvasImage, CanvasText, CanvasWidget
+GNOMEMM_PROPERTY(anchor,anchor,Gtk::AnchorType)
+
+// CanvasPolygon, CanvasRect, CanvasEllipse
+GNOMEMM_PROPERTY(outline_stipple,outline_stipple,Glib::RefPtr<Gdk::Bitmap>)
+GNOMEMM_PROPERTY(wind,wind,guint)
+GNOMEMM_PROPERTY(miterlimit,miterlimit,double)
+
+// CanvasLine, CanvasPolygon, CanvasRect, CanvasEllipse
+GNOMEMM_PROPERTY(width_pixels,width_pixels,guint)
+GNOMEMM_PROPERTY(width_units,width_units,double)
+
+// CanvasGroup, CanvasImage, CanvasText, CanvasWidget
+GNOMEMM_PROPERTY(x,x,double)
+GNOMEMM_PROPERTY(y,y,double)
+
+// CanvasLine, CanvasPolygon, CanvasRect, CanvasEllipse, CanvasText
+GNOMEMM_PROPERTY(fill_stipple,fill_stipple,Glib::RefPtr<Gdk::Bitmap>)
+
+} /* namespace Properties */
+} /* namespace Canvas */
+} /* namespace Gnome */
+
+#endif /* _LIBGNOMECANVASMM_PROPERTIES_H_ */
+
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/rect-ellipse.cc b/libs/libgnomecanvasmm/libgnomecanvasmm/rect-ellipse.cc
new file mode 100644
index 0000000000..2733963ce0
--- /dev/null
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/rect-ellipse.cc
@@ -0,0 +1,180 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <libgnomecanvasmm/rect-ellipse.h>
+#include <libgnomecanvasmm/private/rect-ellipse_p.h>
+
+/* $Id$ */
+
+/* ellipse.cc
+ *
+ * Copyright (C) 1998 EMC Capital Management Inc.
+ * Developed by Havoc Pennington <hp@pobox.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+namespace Gnome
+{
+
+namespace Canvas
+{
+
+RectEllipse::RectEllipse(Group& parent)
+    : Shape(GNOME_CANVAS_SHAPE(g_object_new(get_type(),0)))
+{
+  item_construct(parent);
+}
+
+} /* namespace Canvas */
+} /* namespace Gnome */
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gnome::Canvas::RectEllipse* wrap(GnomeCanvasRE* object, bool take_copy)
+{
+  return dynamic_cast<Gnome::Canvas::RectEllipse *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gnome
+{
+
+namespace Canvas
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& RectEllipse_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &RectEllipse_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gnome_canvas_re_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void RectEllipse_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* RectEllipse_Class::wrap_new(GObject* o)
+{
+  return manage(new RectEllipse((GnomeCanvasRE*)(o)));
+
+}
+
+
+/* The implementation: */
+
+RectEllipse::RectEllipse(const Glib::ConstructParams& construct_params)
+:
+  Shape(construct_params)
+{
+  }
+
+RectEllipse::RectEllipse(GnomeCanvasRE* castitem)
+:
+  Shape((GnomeCanvasShape*)(castitem))
+{
+  }
+
+RectEllipse::~RectEllipse()
+{
+  destroy_();
+}
+
+RectEllipse::CppClassType RectEllipse::rectellipse_class_; // initialize static member
+
+GType RectEllipse::get_type()
+{
+  return rectellipse_class_.init().get_type();
+}
+
+GType RectEllipse::get_base_type()
+{
+  return gnome_canvas_re_get_type();
+}
+
+
+Glib::PropertyProxy<double> RectEllipse::property_x1() 
+{
+  return Glib::PropertyProxy<double>(this, "x1");
+}
+
+Glib::PropertyProxy_ReadOnly<double> RectEllipse::property_x1() const
+{
+  return Glib::PropertyProxy_ReadOnly<double>(this, "x1");
+}
+
+Glib::PropertyProxy<double> RectEllipse::property_y1() 
+{
+  return Glib::PropertyProxy<double>(this, "y1");
+}
+
+Glib::PropertyProxy_ReadOnly<double> RectEllipse::property_y1() const
+{
+  return Glib::PropertyProxy_ReadOnly<double>(this, "y1");
+}
+
+Glib::PropertyProxy<double> RectEllipse::property_x2() 
+{
+  return Glib::PropertyProxy<double>(this, "x2");
+}
+
+Glib::PropertyProxy_ReadOnly<double> RectEllipse::property_x2() const
+{
+  return Glib::PropertyProxy_ReadOnly<double>(this, "x2");
+}
+
+Glib::PropertyProxy<double> RectEllipse::property_y2() 
+{
+  return Glib::PropertyProxy<double>(this, "y2");
+}
+
+Glib::PropertyProxy_ReadOnly<double> RectEllipse::property_y2() const
+{
+  return Glib::PropertyProxy_ReadOnly<double>(this, "y2");
+}
+
+
+} // namespace Canvas
+
+} // namespace Gnome
+
+
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/rect-ellipse.h b/libs/libgnomecanvasmm/libgnomecanvasmm/rect-ellipse.h
new file mode 100644
index 0000000000..9982ce34b2
--- /dev/null
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/rect-ellipse.h
@@ -0,0 +1,196 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _LIBGNOMECANVASMM_RECT_ELLIPSE_H
+#define _LIBGNOMECANVASMM_RECT_ELLIPSE_H
+
+#include <glibmm.h>
+
+// -*- C++ -*-
+/* $Id$ */
+
+/* canvas-ellipse.h
+ * 
+ * Copyright (C) 1998 EMC Capital Management Inc.
+ * Developed by Havoc Pennington <hp@pobox.com>
+ *
+ * Copyright (C) 1999 The Gtk-- Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <libgnomecanvasmm/shape.h>
+//#include <libgnomecanvasmm/group.h>
+#include <libgnomecanvas/gnome-canvas-rect-ellipse.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GnomeCanvasRE GnomeCanvasRE;
+typedef struct _GnomeCanvasREClass GnomeCanvasREClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gnome
+{
+
+namespace Canvas
+{ class RectEllipse_Class; } // namespace Canvas
+
+} // namespace Gnome
+namespace Gnome
+{
+
+namespace Canvas
+{
+
+/** Abstract class for all rectangular shapes
+ * Corresponds to GnomeCanvasRE in libgnomecanvas
+ */
+
+class RectEllipse : public Shape
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef RectEllipse CppObjectType;
+  typedef RectEllipse_Class CppClassType;
+  typedef GnomeCanvasRE BaseObjectType;
+  typedef GnomeCanvasREClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~RectEllipse();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class RectEllipse_Class;
+  static CppClassType rectellipse_class_;
+
+  // noncopyable
+  RectEllipse(const RectEllipse&);
+  RectEllipse& operator=(const RectEllipse&);
+
+protected:
+  explicit RectEllipse(const Glib::ConstructParams& construct_params);
+  explicit RectEllipse(GnomeCanvasRE* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GnomeCanvasRE*       gobj()       { return reinterpret_cast<GnomeCanvasRE*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GnomeCanvasRE* gobj() const { return reinterpret_cast<GnomeCanvasRE*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+private:
+
+public:
+  explicit RectEllipse(Group& parent);
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<double> property_x1() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<double> property_x1() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<double> property_y1() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<double> property_y1() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<double> property_x2() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<double> property_x2() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<double> property_y2() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<double> property_y2() const;
+
+
+};
+
+} /* namespace Canvas */
+} /* namespace Gnome */
+
+namespace Glib
+{
+  /** @relates Gnome::Canvas::RectEllipse
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gnome::Canvas::RectEllipse* wrap(GnomeCanvasRE* object, bool take_copy = false);
+}
+#endif /* _LIBGNOMECANVASMM_RECT_ELLIPSE_H */
+
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/rect.cc b/libs/libgnomecanvasmm/libgnomecanvasmm/rect.cc
new file mode 100644
index 0000000000..68bc53a756
--- /dev/null
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/rect.cc
@@ -0,0 +1,146 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <libgnomecanvasmm/rect.h>
+#include <libgnomecanvasmm/private/rect_p.h>
+
+/* $Id$ */
+
+/* rect.c
+ *
+ * Copyright (C) 1998 EMC Capital Management Inc.
+ * Developed by Havoc Pennington <hp@pobox.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+namespace Gnome
+{
+
+namespace Canvas
+{
+
+Rect::Rect(Group& parentx, double x1, double y1, double x2, double y2)
+: RectEllipse(GNOME_CANVAS_RE(g_object_new(get_type(),0)))
+{
+  item_construct(parentx);
+  set("x1",x1,"y1",y1,"x2",x2,"y2",y2,0);
+}
+
+Rect::Rect(Group& parentx)
+: RectEllipse(GNOME_CANVAS_RE(g_object_new(get_type(),0)))
+{
+  item_construct(parentx);
+}
+
+} /* namespace Canvas */
+} /* namespace Gnome */
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gnome::Canvas::Rect* wrap(GnomeCanvasRect* object, bool take_copy)
+{
+  return dynamic_cast<Gnome::Canvas::Rect *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gnome
+{
+
+namespace Canvas
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& Rect_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &Rect_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gnome_canvas_rect_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void Rect_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* Rect_Class::wrap_new(GObject* o)
+{
+  return manage(new Rect((GnomeCanvasRect*)(o)));
+
+}
+
+
+/* The implementation: */
+
+Rect::Rect(const Glib::ConstructParams& construct_params)
+:
+  RectEllipse(construct_params)
+{
+  }
+
+Rect::Rect(GnomeCanvasRect* castitem)
+:
+  RectEllipse((GnomeCanvasRE*)(castitem))
+{
+  }
+
+Rect::~Rect()
+{
+  destroy_();
+}
+
+Rect::CppClassType Rect::rect_class_; // initialize static member
+
+GType Rect::get_type()
+{
+  return rect_class_.init().get_type();
+}
+
+GType Rect::get_base_type()
+{
+  return gnome_canvas_rect_get_type();
+}
+
+
+} // namespace Canvas
+
+} // namespace Gnome
+
+
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/rect.h b/libs/libgnomecanvasmm/libgnomecanvasmm/rect.h
new file mode 100644
index 0000000000..cebd0c4655
--- /dev/null
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/rect.h
@@ -0,0 +1,132 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _LIBGNOMECANVASMM_RECT_H
+#define _LIBGNOMECANVASMM_RECT_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* rect.h
+ * 
+ * Copyright (C) 1998 EMC Capital Management Inc.
+ * Developed by Havoc Pennington <hp@pobox.com>
+ *
+ * Copyright (C) 1999 The Gtk-- Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <libgnomecanvasmm/item.h>
+#include <libgnomecanvasmm/group.h>
+#include <libgnomecanvasmm/rect-ellipse.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GnomeCanvasRect GnomeCanvasRect;
+typedef struct _GnomeCanvasRectClass GnomeCanvasRectClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gnome
+{
+
+namespace Canvas
+{ class Rect_Class; } // namespace Canvas
+
+} // namespace Gnome
+namespace Gnome
+{
+
+namespace Canvas
+{
+
+//class Group;
+
+
+class Rect : public RectEllipse
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Rect CppObjectType;
+  typedef Rect_Class CppClassType;
+  typedef GnomeCanvasRect BaseObjectType;
+  typedef GnomeCanvasRectClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~Rect();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class Rect_Class;
+  static CppClassType rect_class_;
+
+  // noncopyable
+  Rect(const Rect&);
+  Rect& operator=(const Rect&);
+
+protected:
+  explicit Rect(const Glib::ConstructParams& construct_params);
+  explicit Rect(GnomeCanvasRect* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GnomeCanvasRect*       gobj()       { return reinterpret_cast<GnomeCanvasRect*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GnomeCanvasRect* gobj() const { return reinterpret_cast<GnomeCanvasRect*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+private:
+
+
+public:
+  Rect(Group& parent, double x1, double y1, double x2, double y2);
+  explicit Rect(Group& parent);
+
+
+};
+
+} /* namespace Canvas */
+} /* namespace Gnome */
+
+namespace Glib
+{
+  /** @relates Gnome::Canvas::Rect
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gnome::Canvas::Rect* wrap(GnomeCanvasRect* object, bool take_copy = false);
+}
+#endif /* _LIBGNOMECANVASMM_RECT_H */
+
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/rich-text.cc b/libs/libgnomecanvasmm/libgnomecanvasmm/rich-text.cc
new file mode 100644
index 0000000000..87978b2b1b
--- /dev/null
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/rich-text.cc
@@ -0,0 +1,475 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <libgnomecanvasmm/rich-text.h>
+#include <libgnomecanvasmm/private/rich-text_p.h>
+
+/* $Id$ */
+
+/* rich-text.cc
+ *
+ * Copyright (C) 2002 The libgnomecanvasmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+namespace Gnome
+{
+
+namespace Canvas
+{
+
+RichText::RichText (Group& parent,
+                    double x, double y, 
+                    const Glib::ustring& text)
+  : Item (GNOME_CANVAS_ITEM (g_object_new (get_type (), NULL)))
+{
+  item_construct (parent);
+  set ("x", x, 
+       "y", y, 
+       "text", text.c_str (), 
+       NULL);
+}
+
+RichText::RichText (Group& parent)
+  : Item (GNOME_CANVAS_ITEM (g_object_new (get_type (), NULL)))
+{
+  item_construct (parent);
+}
+
+RichText::iterator RichText::get_iter_at_location(int x, int y) const
+{
+  iterator iter;
+  gnome_canvas_rich_text_get_iter_at_location(const_cast<GnomeCanvasRichText*>(gobj()), iter.gobj(), x, y);
+  return iter;
+}
+
+
+}
+
+}
+
+
+namespace
+{
+
+void RichText_signal_tag_changed_callback(GnomeCanvasRichText* self, GtkTextTag* tag,void* data)
+{
+  using namespace Gnome::Canvas;
+  typedef sigc::slot< void,const Glib::RefPtr<Gtk::TextTag>& > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(Glib::wrap(tag, true)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo RichText_signal_tag_changed_info =
+{
+  "tag_changed",
+  (GCallback) &RichText_signal_tag_changed_callback,
+  (GCallback) &RichText_signal_tag_changed_callback
+};
+
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gnome::Canvas::RichText* wrap(GnomeCanvasRichText* object, bool take_copy)
+{
+  return dynamic_cast<Gnome::Canvas::RichText *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gnome
+{
+
+namespace Canvas
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& RichText_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &RichText_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gnome_canvas_rich_text_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void RichText_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+  klass->tag_changed = &tag_changed_callback;
+}
+
+
+void RichText_Class::tag_changed_callback(GnomeCanvasRichText* self, GtkTextTag* tag)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_tag_changed(Glib::wrap(tag, true)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->tag_changed)
+      (*base->tag_changed)(self, tag);
+  }
+}
+
+
+Glib::ObjectBase* RichText_Class::wrap_new(GObject* o)
+{
+  return manage(new RichText((GnomeCanvasRichText*)(o)));
+
+}
+
+
+/* The implementation: */
+
+RichText::RichText(const Glib::ConstructParams& construct_params)
+:
+  Item(construct_params)
+{
+  }
+
+RichText::RichText(GnomeCanvasRichText* castitem)
+:
+  Item((GnomeCanvasItem*)(castitem))
+{
+  }
+
+RichText::~RichText()
+{
+  destroy_();
+}
+
+RichText::CppClassType RichText::richtext_class_; // initialize static member
+
+GType RichText::get_type()
+{
+  return richtext_class_.init().get_type();
+}
+
+GType RichText::get_base_type()
+{
+  return gnome_canvas_rich_text_get_type();
+}
+
+
+void RichText::cut_clipboard()
+{
+  gnome_canvas_rich_text_cut_clipboard(gobj());
+}
+
+void RichText::copy_clipboard()
+{
+  gnome_canvas_rich_text_copy_clipboard(gobj());
+}
+
+void RichText::paste_clipboard()
+{
+  gnome_canvas_rich_text_paste_clipboard(gobj());
+}
+
+void RichText::set_buffer(const Glib::RefPtr<Gtk::TextBuffer>& buffer)
+{
+  gnome_canvas_rich_text_set_buffer(gobj(), Glib::unwrap(buffer));
+}
+
+Glib::RefPtr<Gtk::TextBuffer> RichText::get_buffer() const
+{
+  return Glib::wrap(gnome_canvas_rich_text_get_buffer(const_cast<GnomeCanvasRichText*>(gobj())));
+}
+
+void RichText::get_iter_location(const iterator& iter, Gdk::Rectangle& location) const
+{
+  gnome_canvas_rich_text_get_iter_location(const_cast<GnomeCanvasRichText*>(gobj()), (iter).gobj(), (location).gobj());
+}
+
+
+Glib::SignalProxy1< void,const Glib::RefPtr<Gtk::TextTag>& > RichText::signal_tag_changed()
+{
+  return Glib::SignalProxy1< void,const Glib::RefPtr<Gtk::TextTag>& >(this, &RichText_signal_tag_changed_info);
+}
+
+
+Glib::PropertyProxy<Glib::ustring> RichText::property_text() 
+{
+  return Glib::PropertyProxy<Glib::ustring>(this, "text");
+}
+
+Glib::PropertyProxy_ReadOnly<Glib::ustring> RichText::property_text() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "text");
+}
+
+Glib::PropertyProxy<double> RichText::property_x() 
+{
+  return Glib::PropertyProxy<double>(this, "x");
+}
+
+Glib::PropertyProxy_ReadOnly<double> RichText::property_x() const
+{
+  return Glib::PropertyProxy_ReadOnly<double>(this, "x");
+}
+
+Glib::PropertyProxy<double> RichText::property_y() 
+{
+  return Glib::PropertyProxy<double>(this, "y");
+}
+
+Glib::PropertyProxy_ReadOnly<double> RichText::property_y() const
+{
+  return Glib::PropertyProxy_ReadOnly<double>(this, "y");
+}
+
+Glib::PropertyProxy<double> RichText::property_width() 
+{
+  return Glib::PropertyProxy<double>(this, "width");
+}
+
+Glib::PropertyProxy_ReadOnly<double> RichText::property_width() const
+{
+  return Glib::PropertyProxy_ReadOnly<double>(this, "width");
+}
+
+Glib::PropertyProxy<double> RichText::property_height() 
+{
+  return Glib::PropertyProxy<double>(this, "height");
+}
+
+Glib::PropertyProxy_ReadOnly<double> RichText::property_height() const
+{
+  return Glib::PropertyProxy_ReadOnly<double>(this, "height");
+}
+
+Glib::PropertyProxy<bool> RichText::property_editable() 
+{
+  return Glib::PropertyProxy<bool>(this, "editable");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> RichText::property_editable() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "editable");
+}
+
+Glib::PropertyProxy<bool> RichText::property_visible() 
+{
+  return Glib::PropertyProxy<bool>(this, "visible");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> RichText::property_visible() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "visible");
+}
+
+Glib::PropertyProxy<bool> RichText::property_cursor_visible() 
+{
+  return Glib::PropertyProxy<bool>(this, "cursor-visible");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> RichText::property_cursor_visible() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "cursor-visible");
+}
+
+Glib::PropertyProxy<bool> RichText::property_cursor_blink() 
+{
+  return Glib::PropertyProxy<bool>(this, "cursor-blink");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> RichText::property_cursor_blink() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "cursor-blink");
+}
+
+Glib::PropertyProxy<bool> RichText::property_grow_height() 
+{
+  return Glib::PropertyProxy<bool>(this, "grow-height");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> RichText::property_grow_height() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "grow-height");
+}
+
+Glib::PropertyProxy<Gtk::WrapMode> RichText::property_wrap_mode() 
+{
+  return Glib::PropertyProxy<Gtk::WrapMode>(this, "wrap-mode");
+}
+
+Glib::PropertyProxy_ReadOnly<Gtk::WrapMode> RichText::property_wrap_mode() const
+{
+  return Glib::PropertyProxy_ReadOnly<Gtk::WrapMode>(this, "wrap-mode");
+}
+
+Glib::PropertyProxy<Gtk::Justification> RichText::property_justification() 
+{
+  return Glib::PropertyProxy<Gtk::Justification>(this, "justification");
+}
+
+Glib::PropertyProxy_ReadOnly<Gtk::Justification> RichText::property_justification() const
+{
+  return Glib::PropertyProxy_ReadOnly<Gtk::Justification>(this, "justification");
+}
+
+Glib::PropertyProxy<Gtk::DirectionType> RichText::property_direction() 
+{
+  return Glib::PropertyProxy<Gtk::DirectionType>(this, "direction");
+}
+
+Glib::PropertyProxy_ReadOnly<Gtk::DirectionType> RichText::property_direction() const
+{
+  return Glib::PropertyProxy_ReadOnly<Gtk::DirectionType>(this, "direction");
+}
+
+Glib::PropertyProxy<Gtk::AnchorType> RichText::property_anchor() 
+{
+  return Glib::PropertyProxy<Gtk::AnchorType>(this, "anchor");
+}
+
+Glib::PropertyProxy_ReadOnly<Gtk::AnchorType> RichText::property_anchor() const
+{
+  return Glib::PropertyProxy_ReadOnly<Gtk::AnchorType>(this, "anchor");
+}
+
+Glib::PropertyProxy<int> RichText::property_pixels_above_lines() 
+{
+  return Glib::PropertyProxy<int>(this, "pixels-above-lines");
+}
+
+Glib::PropertyProxy_ReadOnly<int> RichText::property_pixels_above_lines() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "pixels-above-lines");
+}
+
+Glib::PropertyProxy<int> RichText::property_pixels_below_lines() 
+{
+  return Glib::PropertyProxy<int>(this, "pixels-below-lines");
+}
+
+Glib::PropertyProxy_ReadOnly<int> RichText::property_pixels_below_lines() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "pixels-below-lines");
+}
+
+Glib::PropertyProxy<int> RichText::property_pixels_inside_wrap() 
+{
+  return Glib::PropertyProxy<int>(this, "pixels-inside-wrap");
+}
+
+Glib::PropertyProxy_ReadOnly<int> RichText::property_pixels_inside_wrap() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "pixels-inside-wrap");
+}
+
+Glib::PropertyProxy<int> RichText::property_left_margin() 
+{
+  return Glib::PropertyProxy<int>(this, "left-margin");
+}
+
+Glib::PropertyProxy_ReadOnly<int> RichText::property_left_margin() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "left-margin");
+}
+
+Glib::PropertyProxy<int> RichText::property_right_margin() 
+{
+  return Glib::PropertyProxy<int>(this, "right-margin");
+}
+
+Glib::PropertyProxy_ReadOnly<int> RichText::property_right_margin() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "right-margin");
+}
+
+Glib::PropertyProxy<int> RichText::property_indent() 
+{
+  return Glib::PropertyProxy<int>(this, "indent");
+}
+
+Glib::PropertyProxy_ReadOnly<int> RichText::property_indent() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "indent");
+}
+
+
+void Gnome::Canvas::RichText::on_tag_changed(const Glib::RefPtr<Gtk::TextTag>& tag)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->tag_changed)
+    (*base->tag_changed)(gobj(),Glib::unwrap(tag));
+}
+
+
+} // namespace Canvas
+
+} // namespace Gnome
+
+
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/rich-text.h b/libs/libgnomecanvasmm/libgnomecanvasmm/rich-text.h
new file mode 100644
index 0000000000..32af1680e4
--- /dev/null
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/rich-text.h
@@ -0,0 +1,472 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _LIBGNOMECANVASMM_RICH_TEXT_H
+#define _LIBGNOMECANVASMM_RICH_TEXT_H
+
+#include <glibmm.h>
+
+// -*- C++ -*-
+/* $Id$ */
+
+/* rich-text.h
+ *
+ *
+ * Copyright (C) 2002 The libgnomecanvasmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/textbuffer.h>
+#include <libgnomecanvasmm/item.h>
+#include <libgnomecanvas/gnome-canvas-rich-text.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GnomeCanvasRichText GnomeCanvasRichText;
+typedef struct _GnomeCanvasRichTextClass GnomeCanvasRichTextClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gnome
+{
+
+namespace Canvas
+{ class RichText_Class; } // namespace Canvas
+
+} // namespace Gnome
+namespace Gnome
+{
+
+namespace Canvas
+{
+
+
+class RichText : public Item
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef RichText CppObjectType;
+  typedef RichText_Class CppClassType;
+  typedef GnomeCanvasRichText BaseObjectType;
+  typedef GnomeCanvasRichTextClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~RichText();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class RichText_Class;
+  static CppClassType richtext_class_;
+
+  // noncopyable
+  RichText(const RichText&);
+  RichText& operator=(const RichText&);
+
+protected:
+  explicit RichText(const Glib::ConstructParams& construct_params);
+  explicit RichText(GnomeCanvasRichText* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GnomeCanvasRichText*       gobj()       { return reinterpret_cast<GnomeCanvasRichText*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GnomeCanvasRichText* gobj() const { return reinterpret_cast<GnomeCanvasRichText*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+  virtual void on_tag_changed(const Glib::RefPtr<Gtk::TextTag>& tag);
+
+
+private:
+
+  
+public:
+  typedef Gtk::TextIter iterator;
+
+  RichText(Group& parent, double x, double y, const Glib::ustring& text);
+  explicit RichText(Group& parent);
+
+  
+  void cut_clipboard();
+  
+  void copy_clipboard();
+  
+  void paste_clipboard();
+
+  
+  void set_buffer(const Glib::RefPtr<Gtk::TextBuffer>& buffer);
+  
+  Glib::RefPtr<Gtk::TextBuffer> get_buffer() const;
+
+  
+  void get_iter_location(const iterator& iter, Gdk::Rectangle& location) const;
+   iterator get_iter_at_location(int x, int y) const;
+
+  
+  Glib::SignalProxy1< void,const Glib::RefPtr<Gtk::TextTag>& > signal_tag_changed();
+
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Glib::ustring> property_text() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::ustring> property_text() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<double> property_x() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<double> property_x() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<double> property_y() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<double> property_y() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<double> property_width() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<double> property_width() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<double> property_height() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<double> property_height() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_editable() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_editable() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_visible() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_visible() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_cursor_visible() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_cursor_visible() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_cursor_blink() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_cursor_blink() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_grow_height() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_grow_height() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Gtk::WrapMode> property_wrap_mode() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Gtk::WrapMode> property_wrap_mode() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Gtk::Justification> property_justification() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Gtk::Justification> property_justification() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Gtk::DirectionType> property_direction() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Gtk::DirectionType> property_direction() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Gtk::AnchorType> property_anchor() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Gtk::AnchorType> property_anchor() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<int> property_pixels_above_lines() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_pixels_above_lines() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<int> property_pixels_below_lines() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_pixels_below_lines() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<int> property_pixels_inside_wrap() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_pixels_inside_wrap() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<int> property_left_margin() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_left_margin() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<int> property_right_margin() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_right_margin() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<int> property_indent() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_indent() const;
+
+
+};
+
+} /* namespace Canvas */
+} /* namespace Gnome */
+
+namespace Glib
+{
+  /** @relates Gnome::Canvas::RichText
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gnome::Canvas::RichText* wrap(GnomeCanvasRichText* object, bool take_copy = false);
+}
+#endif /* _LIBGNOMECANVASMM_RICH_TEXT_H */
+
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/shape.cc b/libs/libgnomecanvasmm/libgnomecanvasmm/shape.cc
new file mode 100644
index 0000000000..98dedc0cf8
--- /dev/null
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/shape.cc
@@ -0,0 +1,272 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <libgnomecanvasmm/shape.h>
+#include <libgnomecanvasmm/private/shape_p.h>
+
+/* shape.cc
+ *
+ * Copyright (C) 2002 The libgnomecanvasmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gnome::Canvas::Shape* wrap(GnomeCanvasShape* object, bool take_copy)
+{
+  return dynamic_cast<Gnome::Canvas::Shape *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gnome
+{
+
+namespace Canvas
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& Shape_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &Shape_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gnome_canvas_shape_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void Shape_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* Shape_Class::wrap_new(GObject* o)
+{
+  return manage(new Shape((GnomeCanvasShape*)(o)));
+
+}
+
+
+/* The implementation: */
+
+Shape::Shape(const Glib::ConstructParams& construct_params)
+:
+  Item(construct_params)
+{
+  }
+
+Shape::Shape(GnomeCanvasShape* castitem)
+:
+  Item((GnomeCanvasItem*)(castitem))
+{
+  }
+
+Shape::~Shape()
+{
+  destroy_();
+}
+
+Shape::CppClassType Shape::shape_class_; // initialize static member
+
+GType Shape::get_type()
+{
+  return shape_class_.init().get_type();
+}
+
+GType Shape::get_base_type()
+{
+  return gnome_canvas_shape_get_type();
+}
+
+
+Glib::PropertyProxy_WriteOnly<Glib::ustring> Shape::property_fill_color() 
+{
+  return Glib::PropertyProxy_WriteOnly<Glib::ustring>(this, "fill-color");
+}
+
+Glib::PropertyProxy_ReadOnly<Glib::ustring> Shape::property_fill_color() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "fill-color");
+}
+
+Glib::PropertyProxy<Gdk::Color> Shape::property_fill_color_gdk() 
+{
+  return Glib::PropertyProxy<Gdk::Color>(this, "fill-color-gdk");
+}
+
+Glib::PropertyProxy_ReadOnly<Gdk::Color> Shape::property_fill_color_gdk() const
+{
+  return Glib::PropertyProxy_ReadOnly<Gdk::Color>(this, "fill-color-gdk");
+}
+
+Glib::PropertyProxy<guint> Shape::property_fill_color_rgba() 
+{
+  return Glib::PropertyProxy<guint>(this, "fill-color-rgba");
+}
+
+Glib::PropertyProxy_ReadOnly<guint> Shape::property_fill_color_rgba() const
+{
+  return Glib::PropertyProxy_ReadOnly<guint>(this, "fill-color-rgba");
+}
+
+Glib::PropertyProxy_WriteOnly<Glib::ustring> Shape::property_outline_color() 
+{
+  return Glib::PropertyProxy_WriteOnly<Glib::ustring>(this, "outline-color");
+}
+
+Glib::PropertyProxy_ReadOnly<Glib::ustring> Shape::property_outline_color() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "outline-color");
+}
+
+Glib::PropertyProxy<Gdk::Color> Shape::property_outline_color_gdk() 
+{
+  return Glib::PropertyProxy<Gdk::Color>(this, "outline-color-gdk");
+}
+
+Glib::PropertyProxy_ReadOnly<Gdk::Color> Shape::property_outline_color_gdk() const
+{
+  return Glib::PropertyProxy_ReadOnly<Gdk::Color>(this, "outline-color-gdk");
+}
+
+Glib::PropertyProxy<guint> Shape::property_outline_color_rgba() 
+{
+  return Glib::PropertyProxy<guint>(this, "outline-color-rgba");
+}
+
+Glib::PropertyProxy_ReadOnly<guint> Shape::property_outline_color_rgba() const
+{
+  return Glib::PropertyProxy_ReadOnly<guint>(this, "outline-color-rgba");
+}
+
+Glib::PropertyProxy< Glib::RefPtr<Gdk::Bitmap> > Shape::property_fill_stipple() 
+{
+  return Glib::PropertyProxy< Glib::RefPtr<Gdk::Bitmap> >(this, "fill-stipple");
+}
+
+Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Bitmap> > Shape::property_fill_stipple() const
+{
+  return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Bitmap> >(this, "fill-stipple");
+}
+
+Glib::PropertyProxy< Glib::RefPtr<Gdk::Bitmap> > Shape::property_outline_stipple() 
+{
+  return Glib::PropertyProxy< Glib::RefPtr<Gdk::Bitmap> >(this, "outline-stipple");
+}
+
+Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Bitmap> > Shape::property_outline_stipple() const
+{
+  return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Bitmap> >(this, "outline-stipple");
+}
+
+Glib::PropertyProxy<guint> Shape::property_width_pixels() 
+{
+  return Glib::PropertyProxy<guint>(this, "width-pixels");
+}
+
+Glib::PropertyProxy_ReadOnly<guint> Shape::property_width_pixels() const
+{
+  return Glib::PropertyProxy_ReadOnly<guint>(this, "width-pixels");
+}
+
+Glib::PropertyProxy_WriteOnly<double> Shape::property_width_units() 
+{
+  return Glib::PropertyProxy_WriteOnly<double>(this, "width-units");
+}
+
+Glib::PropertyProxy_ReadOnly<double> Shape::property_width_units() const
+{
+  return Glib::PropertyProxy_ReadOnly<double>(this, "width-units");
+}
+
+Glib::PropertyProxy<Gdk::CapStyle> Shape::property_cap_style() 
+{
+  return Glib::PropertyProxy<Gdk::CapStyle>(this, "cap-style");
+}
+
+Glib::PropertyProxy_ReadOnly<Gdk::CapStyle> Shape::property_cap_style() const
+{
+  return Glib::PropertyProxy_ReadOnly<Gdk::CapStyle>(this, "cap-style");
+}
+
+Glib::PropertyProxy<Gdk::JoinStyle> Shape::property_join_style() 
+{
+  return Glib::PropertyProxy<Gdk::JoinStyle>(this, "join-style");
+}
+
+Glib::PropertyProxy_ReadOnly<Gdk::JoinStyle> Shape::property_join_style() const
+{
+  return Glib::PropertyProxy_ReadOnly<Gdk::JoinStyle>(this, "join-style");
+}
+
+Glib::PropertyProxy<guint> Shape::property_wind() 
+{
+  return Glib::PropertyProxy<guint>(this, "wind");
+}
+
+Glib::PropertyProxy_ReadOnly<guint> Shape::property_wind() const
+{
+  return Glib::PropertyProxy_ReadOnly<guint>(this, "wind");
+}
+
+Glib::PropertyProxy<double> Shape::property_miterlimit() 
+{
+  return Glib::PropertyProxy<double>(this, "miterlimit");
+}
+
+Glib::PropertyProxy_ReadOnly<double> Shape::property_miterlimit() const
+{
+  return Glib::PropertyProxy_ReadOnly<double>(this, "miterlimit");
+}
+
+Glib::PropertyProxy<ArtVpathDash*> Shape::property_dash() 
+{
+  return Glib::PropertyProxy<ArtVpathDash*>(this, "dash");
+}
+
+Glib::PropertyProxy_ReadOnly<ArtVpathDash*> Shape::property_dash() const
+{
+  return Glib::PropertyProxy_ReadOnly<ArtVpathDash*>(this, "dash");
+}
+
+
+} // namespace Canvas
+
+} // namespace Gnome
+
+
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/shape.h b/libs/libgnomecanvasmm/libgnomecanvasmm/shape.h
new file mode 100644
index 0000000000..e1ff6e84f0
--- /dev/null
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/shape.h
@@ -0,0 +1,368 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _LIBGNOMECANVASMM_SHAPE_H
+#define _LIBGNOMECANVASMM_SHAPE_H
+
+#include <glibmm.h>
+
+// -*- C++ -*-
+/* $Id$ */
+
+/* shape.h
+ *
+ *
+ * Copyright (C) 2002 The libgnomecanvasmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <libgnomecanvasmm/item.h>
+#include <libgnomecanvas/gnome-canvas-shape.h>
+#include <libart_lgpl/art_vpath_dash.h> //For ArtVpathDash
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GnomeCanvasShape GnomeCanvasShape;
+typedef struct _GnomeCanvasShapeClass GnomeCanvasShapeClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gnome
+{
+
+namespace Canvas
+{ class Shape_Class; } // namespace Canvas
+
+} // namespace Gnome
+namespace Gnome
+{
+
+namespace Canvas
+{
+
+
+class Shape : public Item
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Shape CppObjectType;
+  typedef Shape_Class CppClassType;
+  typedef GnomeCanvasShape BaseObjectType;
+  typedef GnomeCanvasShapeClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~Shape();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class Shape_Class;
+  static CppClassType shape_class_;
+
+  // noncopyable
+  Shape(const Shape&);
+  Shape& operator=(const Shape&);
+
+protected:
+  explicit Shape(const Glib::ConstructParams& construct_params);
+  explicit Shape(GnomeCanvasShape* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GnomeCanvasShape*       gobj()       { return reinterpret_cast<GnomeCanvasShape*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GnomeCanvasShape* gobj() const { return reinterpret_cast<GnomeCanvasShape*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+private:
+
+  
+public:
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_WriteOnly<Glib::ustring> property_fill_color() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::ustring> property_fill_color() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Gdk::Color> property_fill_color_gdk() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Gdk::Color> property_fill_color_gdk() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<guint> property_fill_color_rgba() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<guint> property_fill_color_rgba() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_WriteOnly<Glib::ustring> property_outline_color() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::ustring> property_outline_color() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Gdk::Color> property_outline_color_gdk() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Gdk::Color> property_outline_color_gdk() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<guint> property_outline_color_rgba() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<guint> property_outline_color_rgba() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy< Glib::RefPtr<Gdk::Bitmap> > property_fill_stipple() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Bitmap> > property_fill_stipple() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy< Glib::RefPtr<Gdk::Bitmap> > property_outline_stipple() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Bitmap> > property_outline_stipple() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<guint> property_width_pixels() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<guint> property_width_pixels() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_WriteOnly<double> property_width_units() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<double> property_width_units() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Gdk::CapStyle> property_cap_style() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Gdk::CapStyle> property_cap_style() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Gdk::JoinStyle> property_join_style() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Gdk::JoinStyle> property_join_style() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<guint> property_wind() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<guint> property_wind() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<double> property_miterlimit() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<double> property_miterlimit() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<ArtVpathDash*> property_dash() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<ArtVpathDash*> property_dash() const;
+ //TODO: Look at ArtVpathDash to see if it should be wrapped.
+
+
+};
+
+} /* namespace Canvas */
+} /* namespace Gnome */
+
+namespace Glib
+{
+  /** @relates Gnome::Canvas::Shape
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gnome::Canvas::Shape* wrap(GnomeCanvasShape* object, bool take_copy = false);
+}
+#endif /* _LIBGNOMECANVASMM_SHAPE_H */
+
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/text.cc b/libs/libgnomecanvasmm/libgnomecanvasmm/text.cc
new file mode 100644
index 0000000000..62ccc4b981
--- /dev/null
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/text.cc
@@ -0,0 +1,557 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <libgnomecanvasmm/text.h>
+#include <libgnomecanvasmm/private/text_p.h>
+
+/* $Id$ */
+
+/* text.cc
+ *
+ * Copyright (C) 1998 EMC Capital Management Inc.
+ * Developed by Havoc Pennington <hp@pobox.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+namespace Gnome
+{
+
+namespace Canvas
+{
+
+Text::Text(Group& parentx, double x, double y, const Glib::ustring& text)
+  : Item(GNOME_CANVAS_ITEM(g_object_new(get_type(), 0)))
+{
+  item_construct(parentx);
+  set("x", x, "y", y, "text", text.c_str(), 0);
+}
+
+Text::Text(Group& parentx)
+  : Item(GNOME_CANVAS_ITEM(g_object_new(get_type(), 0)))
+{
+  item_construct(parentx);
+}
+
+} /* namespace Canvas */
+} /* namespace Gnome */
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gnome::Canvas::Text* wrap(GnomeCanvasText* object, bool take_copy)
+{
+  return dynamic_cast<Gnome::Canvas::Text *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gnome
+{
+
+namespace Canvas
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& Text_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &Text_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gnome_canvas_text_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void Text_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* Text_Class::wrap_new(GObject* o)
+{
+  return manage(new Text((GnomeCanvasText*)(o)));
+
+}
+
+
+/* The implementation: */
+
+Text::Text(const Glib::ConstructParams& construct_params)
+:
+  Item(construct_params)
+{
+  }
+
+Text::Text(GnomeCanvasText* castitem)
+:
+  Item((GnomeCanvasItem*)(castitem))
+{
+  }
+
+Text::~Text()
+{
+  destroy_();
+}
+
+Text::CppClassType Text::text_class_; // initialize static member
+
+GType Text::get_type()
+{
+  return text_class_.init().get_type();
+}
+
+GType Text::get_base_type()
+{
+  return gnome_canvas_text_get_type();
+}
+
+
+Glib::PropertyProxy<Glib::ustring> Text::property_text() 
+{
+  return Glib::PropertyProxy<Glib::ustring>(this, "text");
+}
+
+Glib::PropertyProxy_ReadOnly<Glib::ustring> Text::property_text() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "text");
+}
+
+Glib::PropertyProxy_WriteOnly<Glib::ustring> Text::property_markup() 
+{
+  return Glib::PropertyProxy_WriteOnly<Glib::ustring>(this, "markup");
+}
+
+Glib::PropertyProxy_ReadOnly<Glib::ustring> Text::property_markup() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "markup");
+}
+
+Glib::PropertyProxy<double> Text::property_x() 
+{
+  return Glib::PropertyProxy<double>(this, "x");
+}
+
+Glib::PropertyProxy_ReadOnly<double> Text::property_x() const
+{
+  return Glib::PropertyProxy_ReadOnly<double>(this, "x");
+}
+
+Glib::PropertyProxy<double> Text::property_y() 
+{
+  return Glib::PropertyProxy<double>(this, "y");
+}
+
+Glib::PropertyProxy_ReadOnly<double> Text::property_y() const
+{
+  return Glib::PropertyProxy_ReadOnly<double>(this, "y");
+}
+
+Glib::PropertyProxy<Glib::ustring> Text::property_font() 
+{
+  return Glib::PropertyProxy<Glib::ustring>(this, "font");
+}
+
+Glib::PropertyProxy_ReadOnly<Glib::ustring> Text::property_font() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "font");
+}
+
+Glib::PropertyProxy<Pango::FontDescription> Text::property_font_desc() 
+{
+  return Glib::PropertyProxy<Pango::FontDescription>(this, "font-desc");
+}
+
+Glib::PropertyProxy_ReadOnly<Pango::FontDescription> Text::property_font_desc() const
+{
+  return Glib::PropertyProxy_ReadOnly<Pango::FontDescription>(this, "font-desc");
+}
+
+Glib::PropertyProxy<Glib::ustring> Text::property_family() 
+{
+  return Glib::PropertyProxy<Glib::ustring>(this, "family");
+}
+
+Glib::PropertyProxy_ReadOnly<Glib::ustring> Text::property_family() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "family");
+}
+
+Glib::PropertyProxy<bool> Text::property_family_set() 
+{
+  return Glib::PropertyProxy<bool>(this, "family-set");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Text::property_family_set() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "family-set");
+}
+
+Glib::PropertyProxy<Pango::AttrList> Text::property_attributes() 
+{
+  return Glib::PropertyProxy<Pango::AttrList>(this, "attributes");
+}
+
+Glib::PropertyProxy_ReadOnly<Pango::AttrList> Text::property_attributes() const
+{
+  return Glib::PropertyProxy_ReadOnly<Pango::AttrList>(this, "attributes");
+}
+
+Glib::PropertyProxy<Pango::Style> Text::property_style() 
+{
+  return Glib::PropertyProxy<Pango::Style>(this, "style");
+}
+
+Glib::PropertyProxy_ReadOnly<Pango::Style> Text::property_style() const
+{
+  return Glib::PropertyProxy_ReadOnly<Pango::Style>(this, "style");
+}
+
+Glib::PropertyProxy<bool> Text::property_style_set() 
+{
+  return Glib::PropertyProxy<bool>(this, "style-set");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Text::property_style_set() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "style-set");
+}
+
+Glib::PropertyProxy<Pango::Variant> Text::property_variant() 
+{
+  return Glib::PropertyProxy<Pango::Variant>(this, "variant");
+}
+
+Glib::PropertyProxy_ReadOnly<Pango::Variant> Text::property_variant() const
+{
+  return Glib::PropertyProxy_ReadOnly<Pango::Variant>(this, "variant");
+}
+
+Glib::PropertyProxy<bool> Text::property_variant_set() 
+{
+  return Glib::PropertyProxy<bool>(this, "variant-set");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Text::property_variant_set() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "variant-set");
+}
+
+Glib::PropertyProxy<int> Text::property_weight() 
+{
+  return Glib::PropertyProxy<int>(this, "weight");
+}
+
+Glib::PropertyProxy_ReadOnly<int> Text::property_weight() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "weight");
+}
+
+Glib::PropertyProxy<bool> Text::property_weight_set() 
+{
+  return Glib::PropertyProxy<bool>(this, "weight-set");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Text::property_weight_set() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "weight-set");
+}
+
+Glib::PropertyProxy<Pango::Weight> Text::property_stretch() 
+{
+  return Glib::PropertyProxy<Pango::Weight>(this, "stretch");
+}
+
+Glib::PropertyProxy_ReadOnly<Pango::Weight> Text::property_stretch() const
+{
+  return Glib::PropertyProxy_ReadOnly<Pango::Weight>(this, "stretch");
+}
+
+Glib::PropertyProxy<bool> Text::property_stretch_set() 
+{
+  return Glib::PropertyProxy<bool>(this, "stretch-set");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Text::property_stretch_set() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "stretch-set");
+}
+
+Glib::PropertyProxy<int> Text::property_size() 
+{
+  return Glib::PropertyProxy<int>(this, "size");
+}
+
+Glib::PropertyProxy_ReadOnly<int> Text::property_size() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "size");
+}
+
+Glib::PropertyProxy<bool> Text::property_size_set() 
+{
+  return Glib::PropertyProxy<bool>(this, "size-set");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Text::property_size_set() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "size-set");
+}
+
+Glib::PropertyProxy<double> Text::property_size_points() 
+{
+  return Glib::PropertyProxy<double>(this, "size-points");
+}
+
+Glib::PropertyProxy_ReadOnly<double> Text::property_size_points() const
+{
+  return Glib::PropertyProxy_ReadOnly<double>(this, "size-points");
+}
+
+Glib::PropertyProxy<bool> Text::property_strikethrough() 
+{
+  return Glib::PropertyProxy<bool>(this, "strikethrough");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Text::property_strikethrough() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "strikethrough");
+}
+
+Glib::PropertyProxy<bool> Text::property_strikethrough_set() 
+{
+  return Glib::PropertyProxy<bool>(this, "strikethrough-set");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Text::property_strikethrough_set() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "strikethrough-set");
+}
+
+Glib::PropertyProxy<Pango::Underline> Text::property_underline() 
+{
+  return Glib::PropertyProxy<Pango::Underline>(this, "underline");
+}
+
+Glib::PropertyProxy_ReadOnly<Pango::Underline> Text::property_underline() const
+{
+  return Glib::PropertyProxy_ReadOnly<Pango::Underline>(this, "underline");
+}
+
+Glib::PropertyProxy<bool> Text::property_underline_set() 
+{
+  return Glib::PropertyProxy<bool>(this, "underline-set");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Text::property_underline_set() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "underline-set");
+}
+
+Glib::PropertyProxy<int> Text::property_rise() 
+{
+  return Glib::PropertyProxy<int>(this, "rise");
+}
+
+Glib::PropertyProxy_ReadOnly<int> Text::property_rise() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "rise");
+}
+
+Glib::PropertyProxy<bool> Text::property_rise_set() 
+{
+  return Glib::PropertyProxy<bool>(this, "rise-set");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Text::property_rise_set() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "rise-set");
+}
+
+Glib::PropertyProxy<double> Text::property_scale() 
+{
+  return Glib::PropertyProxy<double>(this, "scale");
+}
+
+Glib::PropertyProxy_ReadOnly<double> Text::property_scale() const
+{
+  return Glib::PropertyProxy_ReadOnly<double>(this, "scale");
+}
+
+Glib::PropertyProxy<bool> Text::property_scale_set() 
+{
+  return Glib::PropertyProxy<bool>(this, "scale-set");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Text::property_scale_set() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "scale-set");
+}
+
+Glib::PropertyProxy<Gtk::AnchorType> Text::property_anchor() 
+{
+  return Glib::PropertyProxy<Gtk::AnchorType>(this, "anchor");
+}
+
+Glib::PropertyProxy_ReadOnly<Gtk::AnchorType> Text::property_anchor() const
+{
+  return Glib::PropertyProxy_ReadOnly<Gtk::AnchorType>(this, "anchor");
+}
+
+Glib::PropertyProxy<Gtk::Justification> Text::property_justification() 
+{
+  return Glib::PropertyProxy<Gtk::Justification>(this, "justification");
+}
+
+Glib::PropertyProxy_ReadOnly<Gtk::Justification> Text::property_justification() const
+{
+  return Glib::PropertyProxy_ReadOnly<Gtk::Justification>(this, "justification");
+}
+
+Glib::PropertyProxy<double> Text::property_clip_width() 
+{
+  return Glib::PropertyProxy<double>(this, "clip-width");
+}
+
+Glib::PropertyProxy_ReadOnly<double> Text::property_clip_width() const
+{
+  return Glib::PropertyProxy_ReadOnly<double>(this, "clip-width");
+}
+
+Glib::PropertyProxy<double> Text::property_clip_height() 
+{
+  return Glib::PropertyProxy<double>(this, "clip-height");
+}
+
+Glib::PropertyProxy_ReadOnly<double> Text::property_clip_height() const
+{
+  return Glib::PropertyProxy_ReadOnly<double>(this, "clip-height");
+}
+
+Glib::PropertyProxy<bool> Text::property_clip() 
+{
+  return Glib::PropertyProxy<bool>(this, "clip");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Text::property_clip() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "clip");
+}
+
+Glib::PropertyProxy<double> Text::property_x_offset() 
+{
+  return Glib::PropertyProxy<double>(this, "x-offset");
+}
+
+Glib::PropertyProxy_ReadOnly<double> Text::property_x_offset() const
+{
+  return Glib::PropertyProxy_ReadOnly<double>(this, "x-offset");
+}
+
+Glib::PropertyProxy<double> Text::property_y_offset() 
+{
+  return Glib::PropertyProxy<double>(this, "y-offset");
+}
+
+Glib::PropertyProxy_ReadOnly<double> Text::property_y_offset() const
+{
+  return Glib::PropertyProxy_ReadOnly<double>(this, "y-offset");
+}
+
+Glib::PropertyProxy<Glib::ustring> Text::property_fill_color() 
+{
+  return Glib::PropertyProxy<Glib::ustring>(this, "fill-color");
+}
+
+Glib::PropertyProxy_ReadOnly<Glib::ustring> Text::property_fill_color() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "fill-color");
+}
+
+Glib::PropertyProxy<Gdk::Color> Text::property_fill_color_gdk() 
+{
+  return Glib::PropertyProxy<Gdk::Color>(this, "fill-color-gdk");
+}
+
+Glib::PropertyProxy_ReadOnly<Gdk::Color> Text::property_fill_color_gdk() const
+{
+  return Glib::PropertyProxy_ReadOnly<Gdk::Color>(this, "fill-color-gdk");
+}
+
+Glib::PropertyProxy<guint> Text::property_fill_color_rgba() 
+{
+  return Glib::PropertyProxy<guint>(this, "fill-color-rgba");
+}
+
+Glib::PropertyProxy_ReadOnly<guint> Text::property_fill_color_rgba() const
+{
+  return Glib::PropertyProxy_ReadOnly<guint>(this, "fill-color-rgba");
+}
+
+Glib::PropertyProxy< Glib::RefPtr<Gdk::Bitmap> > Text::property_fill_stipple() 
+{
+  return Glib::PropertyProxy< Glib::RefPtr<Gdk::Bitmap> >(this, "fill-stipple");
+}
+
+Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Bitmap> > Text::property_fill_stipple() const
+{
+  return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Bitmap> >(this, "fill-stipple");
+}
+
+Glib::PropertyProxy<double> Text::property_text_width() 
+{
+  return Glib::PropertyProxy<double>(this, "text-width");
+}
+
+Glib::PropertyProxy_ReadOnly<double> Text::property_text_width() const
+{
+  return Glib::PropertyProxy_ReadOnly<double>(this, "text-width");
+}
+
+Glib::PropertyProxy<double> Text::property_text_height() 
+{
+  return Glib::PropertyProxy<double>(this, "text-height");
+}
+
+Glib::PropertyProxy_ReadOnly<double> Text::property_text_height() const
+{
+  return Glib::PropertyProxy_ReadOnly<double>(this, "text-height");
+}
+
+
+} // namespace Canvas
+
+} // namespace Gnome
+
+
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/text.h b/libs/libgnomecanvasmm/libgnomecanvasmm/text.h
new file mode 100644
index 0000000000..d73285c5af
--- /dev/null
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/text.h
@@ -0,0 +1,788 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _LIBGNOMECANVASMM_TEXT_H
+#define _LIBGNOMECANVASMM_TEXT_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* text.h
+ * 
+ * Copyright (C) 1998 EMC Capital Management Inc.
+ * Developed by Havoc Pennington <hp@pobox.com>
+ *
+ * Copyright (C) 1999 The Gtk-- Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <libgnomecanvasmm/item.h>
+#include <pangomm/attrlist.h>
+#include <gtkmm/enums.h>
+#include <libgnomecanvas/gnome-canvas-text.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GnomeCanvasText GnomeCanvasText;
+typedef struct _GnomeCanvasTextClass GnomeCanvasTextClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gnome
+{
+
+namespace Canvas
+{ class Text_Class; } // namespace Canvas
+
+} // namespace Gnome
+namespace Gnome
+{
+
+namespace Canvas
+{
+
+class Group;
+
+
+class Text : public Item
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Text CppObjectType;
+  typedef Text_Class CppClassType;
+  typedef GnomeCanvasText BaseObjectType;
+  typedef GnomeCanvasTextClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~Text();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class Text_Class;
+  static CppClassType text_class_;
+
+  // noncopyable
+  Text(const Text&);
+  Text& operator=(const Text&);
+
+protected:
+  explicit Text(const Glib::ConstructParams& construct_params);
+  explicit Text(GnomeCanvasText* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GnomeCanvasText*       gobj()       { return reinterpret_cast<GnomeCanvasText*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GnomeCanvasText* gobj() const { return reinterpret_cast<GnomeCanvasText*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+private:
+
+public:
+  Text(Group& parent, double x, double y, const Glib::ustring& text);
+  explicit Text(Group& parent);
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Glib::ustring> property_text() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::ustring> property_text() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_WriteOnly<Glib::ustring> property_markup() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::ustring> property_markup() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<double> property_x() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<double> property_x() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<double> property_y() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<double> property_y() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Glib::ustring> property_font() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::ustring> property_font() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Pango::FontDescription> property_font_desc() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Pango::FontDescription> property_font_desc() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Glib::ustring> property_family() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::ustring> property_family() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_family_set() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_family_set() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Pango::AttrList> property_attributes() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Pango::AttrList> property_attributes() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Pango::Style> property_style() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Pango::Style> property_style() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_style_set() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_style_set() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Pango::Variant> property_variant() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Pango::Variant> property_variant() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_variant_set() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_variant_set() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<int> property_weight() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_weight() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_weight_set() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_weight_set() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Pango::Weight> property_stretch() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Pango::Weight> property_stretch() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_stretch_set() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_stretch_set() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<int> property_size() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_size() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_size_set() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_size_set() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<double> property_size_points() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<double> property_size_points() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_strikethrough() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_strikethrough() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_strikethrough_set() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_strikethrough_set() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Pango::Underline> property_underline() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Pango::Underline> property_underline() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_underline_set() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_underline_set() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<int> property_rise() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_rise() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_rise_set() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_rise_set() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<double> property_scale() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<double> property_scale() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_scale_set() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_scale_set() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Gtk::AnchorType> property_anchor() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Gtk::AnchorType> property_anchor() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Gtk::Justification> property_justification() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Gtk::Justification> property_justification() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<double> property_clip_width() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<double> property_clip_width() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<double> property_clip_height() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<double> property_clip_height() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_clip() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_clip() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<double> property_x_offset() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<double> property_x_offset() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<double> property_y_offset() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<double> property_y_offset() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Glib::ustring> property_fill_color() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::ustring> property_fill_color() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Gdk::Color> property_fill_color_gdk() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Gdk::Color> property_fill_color_gdk() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<guint> property_fill_color_rgba() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<guint> property_fill_color_rgba() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy< Glib::RefPtr<Gdk::Bitmap> > property_fill_stipple() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Bitmap> > property_fill_stipple() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<double> property_text_width() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<double> property_text_width() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<double> property_text_height() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<double> property_text_height() const;
+
+
+};
+
+} /* namespace Canvas */
+} /* namespace Gnome */
+
+namespace Glib
+{
+  /** @relates Gnome::Canvas::Text
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gnome::Canvas::Text* wrap(GnomeCanvasText* object, bool take_copy = false);
+}
+#endif /* _LIBGNOMECANVASMM_TEXT_H */
+
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/widget.cc b/libs/libgnomecanvasmm/libgnomecanvasmm/widget.cc
new file mode 100644
index 0000000000..ab9709f629
--- /dev/null
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/widget.cc
@@ -0,0 +1,220 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <libgnomecanvasmm/widget.h>
+#include <libgnomecanvasmm/private/widget_p.h>
+
+/* $Id$ */
+
+/* widget.cc
+ *
+ * Copyright (C) 1998 EMC Capital Management Inc.
+ * Developed by Havoc Pennington <hp@pobox.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+#include <stdarg.h>
+#include <gtkmm/widget.h>
+
+namespace Gnome
+{
+
+namespace Canvas
+{
+
+Widget::Widget(Group& parentx, double x, double y,
+                           Gtk::Widget& w)
+  : Item(GNOME_CANVAS_ITEM(g_object_new(get_type(),0)))
+{
+  item_construct(parentx);
+  set("x", x, "y", y, "widget",w.gobj(), 0);
+}
+
+Widget::Widget(Group& parentx)
+  : Item(GNOME_CANVAS_ITEM(g_object_new(get_type(),0)))
+{
+  item_construct(parentx);
+}
+
+} /* namespace Canvas */
+} /* namespace Gnome */
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gnome::Canvas::Widget* wrap(GnomeCanvasWidget* object, bool take_copy)
+{
+  return dynamic_cast<Gnome::Canvas::Widget *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gnome
+{
+
+namespace Canvas
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& Widget_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &Widget_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gnome_canvas_widget_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void Widget_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* Widget_Class::wrap_new(GObject* o)
+{
+  return manage(new Widget((GnomeCanvasWidget*)(o)));
+
+}
+
+
+/* The implementation: */
+
+Widget::Widget(const Glib::ConstructParams& construct_params)
+:
+  Item(construct_params)
+{
+  }
+
+Widget::Widget(GnomeCanvasWidget* castitem)
+:
+  Item((GnomeCanvasItem*)(castitem))
+{
+  }
+
+Widget::~Widget()
+{
+  destroy_();
+}
+
+Widget::CppClassType Widget::widget_class_; // initialize static member
+
+GType Widget::get_type()
+{
+  return widget_class_.init().get_type();
+}
+
+GType Widget::get_base_type()
+{
+  return gnome_canvas_widget_get_type();
+}
+
+
+Glib::PropertyProxy<Gtk::Widget*> Widget::property_widget() 
+{
+  return Glib::PropertyProxy<Gtk::Widget*>(this, "widget");
+}
+
+Glib::PropertyProxy_ReadOnly<Gtk::Widget*> Widget::property_widget() const
+{
+  return Glib::PropertyProxy_ReadOnly<Gtk::Widget*>(this, "widget");
+}
+
+Glib::PropertyProxy<double> Widget::property_x() 
+{
+  return Glib::PropertyProxy<double>(this, "x");
+}
+
+Glib::PropertyProxy_ReadOnly<double> Widget::property_x() const
+{
+  return Glib::PropertyProxy_ReadOnly<double>(this, "x");
+}
+
+Glib::PropertyProxy<double> Widget::property_y() 
+{
+  return Glib::PropertyProxy<double>(this, "y");
+}
+
+Glib::PropertyProxy_ReadOnly<double> Widget::property_y() const
+{
+  return Glib::PropertyProxy_ReadOnly<double>(this, "y");
+}
+
+Glib::PropertyProxy<double> Widget::property_width() 
+{
+  return Glib::PropertyProxy<double>(this, "width");
+}
+
+Glib::PropertyProxy_ReadOnly<double> Widget::property_width() const
+{
+  return Glib::PropertyProxy_ReadOnly<double>(this, "width");
+}
+
+Glib::PropertyProxy<double> Widget::property_height() 
+{
+  return Glib::PropertyProxy<double>(this, "height");
+}
+
+Glib::PropertyProxy_ReadOnly<double> Widget::property_height() const
+{
+  return Glib::PropertyProxy_ReadOnly<double>(this, "height");
+}
+
+Glib::PropertyProxy<Gtk::AnchorType> Widget::property_anchor() 
+{
+  return Glib::PropertyProxy<Gtk::AnchorType>(this, "anchor");
+}
+
+Glib::PropertyProxy_ReadOnly<Gtk::AnchorType> Widget::property_anchor() const
+{
+  return Glib::PropertyProxy_ReadOnly<Gtk::AnchorType>(this, "anchor");
+}
+
+Glib::PropertyProxy<bool> Widget::property_size_pixels() 
+{
+  return Glib::PropertyProxy<bool>(this, "size-pixels");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Widget::property_size_pixels() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "size-pixels");
+}
+
+
+} // namespace Canvas
+
+} // namespace Gnome
+
+
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/widget.h b/libs/libgnomecanvasmm/libgnomecanvasmm/widget.h
new file mode 100644
index 0000000000..0a087f23b3
--- /dev/null
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/widget.h
@@ -0,0 +1,244 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _LIBGNOMECANVASMM_WIDGET_H
+#define _LIBGNOMECANVASMM_WIDGET_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* widget.h
+ * 
+ * Copyright (C) 1998 EMC Capital Management Inc.
+ * Developed by Havoc Pennington <hp@pobox.com>
+ *
+ * Copyright (C) 1999 The Gtk-- Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <libgnomecanvasmm/item.h>
+#include <libgnomecanvas/gnome-canvas-widget.h>
+#include <gtkmm/widget.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GnomeCanvasWidget GnomeCanvasWidget;
+typedef struct _GnomeCanvasWidgetClass GnomeCanvasWidgetClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gnome
+{
+
+namespace Canvas
+{ class Widget_Class; } // namespace Canvas
+
+} // namespace Gnome
+namespace Gnome
+{
+
+namespace Canvas
+{
+
+class Group;
+
+
+class Widget : public Item
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Widget CppObjectType;
+  typedef Widget_Class CppClassType;
+  typedef GnomeCanvasWidget BaseObjectType;
+  typedef GnomeCanvasWidgetClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~Widget();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class Widget_Class;
+  static CppClassType widget_class_;
+
+  // noncopyable
+  Widget(const Widget&);
+  Widget& operator=(const Widget&);
+
+protected:
+  explicit Widget(const Glib::ConstructParams& construct_params);
+  explicit Widget(GnomeCanvasWidget* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GnomeCanvasWidget*       gobj()       { return reinterpret_cast<GnomeCanvasWidget*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GnomeCanvasWidget* gobj() const { return reinterpret_cast<GnomeCanvasWidget*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+private:
+
+public:
+  Widget(Group& parent, double x, double y, Gtk::Widget& w);
+  explicit Widget(Group& parent);
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Gtk::Widget*> property_widget() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Gtk::Widget*> property_widget() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<double> property_x() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<double> property_x() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<double> property_y() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<double> property_y() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<double> property_width() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<double> property_width() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<double> property_height() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<double> property_height() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Gtk::AnchorType> property_anchor() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Gtk::AnchorType> property_anchor() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_size_pixels() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_size_pixels() const;
+
+
+};
+
+} /* namespace Canvas */
+} /* namespace Gnome */
+
+
+namespace Glib
+{
+  /** @relates Gnome::Canvas::Widget
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gnome::Canvas::Widget* wrap(GnomeCanvasWidget* object, bool take_copy = false);
+}
+#endif /* _LIBGNOMECANVASMM_WIDGET_H */
+
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/wrap_init.cc b/libs/libgnomecanvasmm/libgnomecanvasmm/wrap_init.cc
new file mode 100644
index 0000000000..dc7ccd26f1
--- /dev/null
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/wrap_init.cc
@@ -0,0 +1,116 @@
+
+#include <glib.h>
+
+// Disable the 'const' function attribute of the get_type() functions.
+// GCC would optimize them out because we don't use the return value.
+#undef  G_GNUC_CONST
+#define G_GNUC_CONST /* empty */
+
+#include <libgnomecanvasmm/wrap_init.h>
+#include <glibmm/error.h>
+#include <glibmm/object.h>
+
+// #include the widget headers so that we can call the get_type() static methods:
+
+#include "canvas.h"
+#include "ellipse.h"
+#include "rect.h"
+#include "group.h"
+#include "item.h"
+#include "line.h"
+#include "polygon.h"
+#include "rect-ellipse.h"
+#include "shape.h"
+#include "pixbuf.h"
+#include "rich-text.h"
+#include "text.h"
+#include "widget.h"
+#include "path-def.h"
+#include "bpath.h"
+
+extern "C"
+{
+
+//Declarations of the *_get_type() functions:
+
+GType gnome_canvas_bpath_get_type(void);
+GType gnome_canvas_get_type(void);
+GType gnome_canvas_ellipse_get_type(void);
+GType gnome_canvas_group_get_type(void);
+GType gnome_canvas_item_get_type(void);
+GType gnome_canvas_line_get_type(void);
+GType gnome_canvas_pixbuf_get_type(void);
+GType gnome_canvas_polygon_get_type(void);
+GType gnome_canvas_rect_get_type(void);
+GType gnome_canvas_re_get_type(void);
+GType gnome_canvas_rich_text_get_type(void);
+GType gnome_canvas_shape_get_type(void);
+GType gnome_canvas_text_get_type(void);
+GType gnome_canvas_widget_get_type(void);
+
+//Declarations of the *_error_quark() functions:
+
+} // extern "C"
+
+
+//Declarations of the *_Class::wrap_new() methods, instead of including all the private headers:
+
+namespace Gnome { namespace Canvas {  class Bpath_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  } }
+namespace Gnome { namespace Canvas {  class Canvas_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  } }
+namespace Gnome { namespace Canvas {  class Ellipse_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  } }
+namespace Gnome { namespace Canvas {  class Group_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  } }
+namespace Gnome { namespace Canvas {  class Item_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  } }
+namespace Gnome { namespace Canvas {  class Line_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  } }
+namespace Gnome { namespace Canvas {  class Pixbuf_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  } }
+namespace Gnome { namespace Canvas {  class Polygon_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  } }
+namespace Gnome { namespace Canvas {  class Rect_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  } }
+namespace Gnome { namespace Canvas {  class RectEllipse_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  } }
+namespace Gnome { namespace Canvas {  class RichText_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  } }
+namespace Gnome { namespace Canvas {  class Shape_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  } }
+namespace Gnome { namespace Canvas {  class Text_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  } }
+namespace Gnome { namespace Canvas {  class Widget_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  } }
+
+namespace Gnome { namespace Canvas { 
+
+void wrap_init()
+{
+  // Register Error domains:
+
+// Map gtypes to gtkmm wrapper-creation functions:
+  Glib::wrap_register(gnome_canvas_bpath_get_type(), &Gnome::Canvas::Bpath_Class::wrap_new);
+  Glib::wrap_register(gnome_canvas_get_type(), &Gnome::Canvas::Canvas_Class::wrap_new);
+  Glib::wrap_register(gnome_canvas_ellipse_get_type(), &Gnome::Canvas::Ellipse_Class::wrap_new);
+  Glib::wrap_register(gnome_canvas_group_get_type(), &Gnome::Canvas::Group_Class::wrap_new);
+  Glib::wrap_register(gnome_canvas_item_get_type(), &Gnome::Canvas::Item_Class::wrap_new);
+  Glib::wrap_register(gnome_canvas_line_get_type(), &Gnome::Canvas::Line_Class::wrap_new);
+  Glib::wrap_register(gnome_canvas_pixbuf_get_type(), &Gnome::Canvas::Pixbuf_Class::wrap_new);
+  Glib::wrap_register(gnome_canvas_polygon_get_type(), &Gnome::Canvas::Polygon_Class::wrap_new);
+  Glib::wrap_register(gnome_canvas_rect_get_type(), &Gnome::Canvas::Rect_Class::wrap_new);
+  Glib::wrap_register(gnome_canvas_re_get_type(), &Gnome::Canvas::RectEllipse_Class::wrap_new);
+  Glib::wrap_register(gnome_canvas_rich_text_get_type(), &Gnome::Canvas::RichText_Class::wrap_new);
+  Glib::wrap_register(gnome_canvas_shape_get_type(), &Gnome::Canvas::Shape_Class::wrap_new);
+  Glib::wrap_register(gnome_canvas_text_get_type(), &Gnome::Canvas::Text_Class::wrap_new);
+  Glib::wrap_register(gnome_canvas_widget_get_type(), &Gnome::Canvas::Widget_Class::wrap_new);
+
+  // Register the gtkmm gtypes:
+  Gnome::Canvas::Bpath::get_type();
+  Gnome::Canvas::Canvas::get_type();
+  Gnome::Canvas::Ellipse::get_type();
+  Gnome::Canvas::Group::get_type();
+  Gnome::Canvas::Item::get_type();
+  Gnome::Canvas::Line::get_type();
+  Gnome::Canvas::Pixbuf::get_type();
+  Gnome::Canvas::Polygon::get_type();
+  Gnome::Canvas::Rect::get_type();
+  Gnome::Canvas::RectEllipse::get_type();
+  Gnome::Canvas::RichText::get_type();
+  Gnome::Canvas::Shape::get_type();
+  Gnome::Canvas::Text::get_type();
+  Gnome::Canvas::Widget::get_type();
+
+} // wrap_init()
+
+} //Canvas
+} //Gnome
+
+
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/wrap_init.h b/libs/libgnomecanvasmm/libgnomecanvasmm/wrap_init.h
new file mode 100644
index 0000000000..0438dc43e3
--- /dev/null
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/wrap_init.h
@@ -0,0 +1,36 @@
+#ifndef _LIBGNOMECANVASMM_WRAP_INIT_H
+#define _LIBGNOMECANVASMM_WRAP_INIT_H
+
+/* wrap_init.h
+ *
+ * Copyright (C) 1998-2001 The libgnomeuimm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+// wrap_init.cc is generated by tools/generate_wrap_init.pl
+
+namespace Gnome
+{
+
+namespace Canvas
+{
+
+void wrap_init();
+
+} /* namespace Canvas */
+} /* namespace Gnome */
+
+#endif // _LIBGNOMECANVASMM_WRAP_INIT_H
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmmconfig.h b/libs/libgnomecanvasmm/libgnomecanvasmmconfig.h
new file mode 100644
index 0000000000..a1d3378c29
--- /dev/null
+++ b/libs/libgnomecanvasmm/libgnomecanvasmmconfig.h
@@ -0,0 +1,11 @@
+#ifndef _LIBGNOMEUIMM_CONFIG_H
+#define _LIBGNOMEUIMM_CONFIG_H 1
+
+#include <gtkmmconfig.h>
+
+/* version numbers */
+#define LIBGNOMEUIMM_MAJOR_VERSION 2
+#define LIBGNOMEUIMM_MINOR_VERSION 10
+#define LIBGNOMEUIMM_MICRO_VERSION 0
+
+#endif /* _LIBGNOMEUIMM_CONFIG_H */